hamtaa-texttools 1.3.1__py3-none-any.whl → 2.0.0__py3-none-any.whl

texttools/tools/sync_tools.py

@@ -4,7 +4,6 @@ from typing import Any, Literal
 
 from openai import OpenAI
 
-from ..core.engine import text_to_chunks
 from ..core.exceptions import LLMError, PromptError, TextToolsError, ValidationError
 from ..core.internal_models import (
     Bool,
@@ -15,15 +14,11 @@ from ..core.internal_models import (
     create_dynamic_model,
 )
 from ..core.operators.sync_operator import Operator
+from ..core.utils import TheToolUtils
 from ..models import CategoryTree, ToolOutput, ToolOutputMetadata
 
 
 class TheTool:
-    """
-    Each method configures the operator with a specific YAML prompt,
-    output schema, and flags, then delegates execution to `operator.run()`.
-    """
-
     def __init__(
         self,
         client: OpenAI,
@@ -45,16 +40,16 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Categorize a text into a category / category tree.
+        Classify text into given categories
 
         Important Note: category_tree mode is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
             categories: The category list / category tree
-            with_analysis: Whether to include detailed reasoning analysis
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -167,27 +162,29 @@ class TheTool:
     def extract_keywords(
         self,
         text: str,
+        mode: Literal["auto", "threshold", "count"],
+        number_of_keywords: int | None = None,
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
         top_logprobs: int = 3,
-        mode: Literal["auto", "threshold", "count"] = "auto",
-        number_of_keywords: int | None = None,
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Extract salient keywords from text.
+        Extract keywords from the text
 
         Arguments:
             text: The input text
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            mode: auto -> decide n of keywords automatically, threshold -> decide n of keywords by a threshold, count -> takes number of keywords as the parameter
+            number_of_keywords: Must be set only when using "count" mode
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -204,20 +201,20 @@ class TheTool:
             operator_output = self._operator.run(
                 # User parameters
                 text=text,
+                number_of_keywords=number_of_keywords,
+                mode=mode,
                 with_analysis=with_analysis,
                 output_lang=output_lang,
                 user_prompt=user_prompt,
                 temperature=temperature,
                 logprobs=logprobs,
                 top_logprobs=top_logprobs,
-                number_of_keywords=number_of_keywords,
                 validator=validator,
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
                 tool_name=tool_name,
                 output_model=ListStr,
-                mode=mode,
             )
 
             metadata = ToolOutputMetadata(
@@ -241,7 +238,7 @@ class TheTool:
     def extract_entities(
         self,
         text: str,
-        entities: list[str] | None = None,
+        entities: list[str] = ["all named entities"],
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
@@ -253,15 +250,15 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Perform Named Entity Recognition (NER) over the input text.
+        Perform Named Entity Recognition (NER)
 
         Arguments:
             text: The input text
-            entities: List of entities provided by user
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            entities: List of entities
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -278,8 +275,7 @@ class TheTool:
             operator_output = self._operator.run(
                 # User parameters
                 text=text,
-                entities=entities
-                or "all named entities (e.g., PER, ORG, LOC, DAT, etc.)",
+                entities=entities,
                 with_analysis=with_analysis,
                 output_lang=output_lang,
                 user_prompt=user_prompt,
@@ -330,9 +326,9 @@ class TheTool:
 
         Arguments:
             text: The input text
-            with_analysis: Whether to include detailed reasoning analysis
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -382,10 +378,11 @@ class TheTool:
 
         return tool_output
 
-    def text_to_question(
+    def to_question(
         self,
         text: str,
         number_of_questions: int,
+        mode: Literal["from_text", "from_subject"],
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
@@ -397,15 +394,16 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Generate a single question from the given text.
+        Generate questions from the given text / subject
 
         Arguments:
             text: The input text
+            mode: from_text -> generate questions from an answer, from_subject -> generate questions from a subject
             number_of_questions: Number of questions to generate
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -415,7 +413,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = "text_to_question"
+        tool_name = "to_question"
         start = perf_counter()
 
         try:
@@ -423,6 +421,7 @@ class TheTool:
                 # User parameters
                 text=text,
                 number_of_questions=number_of_questions,
+                mode=mode,
                 with_analysis=with_analysis,
                 output_lang=output_lang,
                 user_prompt=user_prompt,
@@ -435,7 +434,6 @@ class TheTool:
                 # Internal parameters
                 tool_name=tool_name,
                 output_model=ReasonListStr,
-                mode=None,
             )
 
             metadata = ToolOutputMetadata(
@@ -459,26 +457,27 @@ class TheTool:
     def merge_questions(
         self,
         text: list[str],
+        mode: Literal["simple", "stepwise"],
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
         top_logprobs: int = 3,
-        mode: Literal["default", "reason"] = "default",
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Merge multiple questions into a single unified question.
+        Merge multiple questions into a single unified question
 
         Arguments:
             text: List of questions to merge
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            mode: simple -> regular question merging, stepwise -> merge questions in two steps
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -496,6 +495,7 @@ class TheTool:
             operator_output = self._operator.run(
                 # User parameters
                 text=text,
+                mode=mode,
                 with_analysis=with_analysis,
                 output_lang=output_lang,
                 user_prompt=user_prompt,
@@ -508,7 +508,6 @@ class TheTool:
                 # Internal parameters
                 tool_name=tool_name,
                 output_model=Str,
-                mode=mode,
             )
 
             metadata = ToolOutputMetadata(
@@ -529,29 +528,30 @@ class TheTool:
 
         return tool_output
 
-    def rewrite(
+    def augment(
         self,
         text: str,
+        mode: Literal["positive", "negative", "hard_negative"],
         with_analysis: bool = False,
         output_lang: str | None = None,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
         top_logprobs: int = 3,
-        mode: Literal["positive", "negative", "hard_negative"] = "positive",
         validator: Callable[[Any], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Rewrite a text with different modes.
+        Rewrite text in different augmentations
 
         Arguments:
             text: The input text
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            mode: positive -> positive augmentation, negative -> negative augmentation, hard_negative -> hard negative augmentation
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -561,87 +561,14 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = "rewrite"
+        tool_name = "augment"
         start = perf_counter()
 
         try:
             operator_output = self._operator.run(
                 # User parameters
                 text=text,
-                with_analysis=with_analysis,
-                output_lang=output_lang,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                tool_name=tool_name,
-                output_model=Str,
                 mode=mode,
-            )
-
-            metadata = ToolOutputMetadata(
-                tool_name=tool_name, execution_time=perf_counter() - start
-            )
-            tool_output = ToolOutput(
-                result=operator_output.result,
-                logprobs=operator_output.logprobs,
-                analysis=operator_output.analysis,
-                metadata=metadata,
-            )
-
-        except (PromptError, LLMError, ValidationError, TextToolsError, Exception) as e:
-            metadata = ToolOutputMetadata(tool_name=tool_name)
-            tool_output = ToolOutput(
-                errors=[f"{type(e).__name__}: {e}"], metadata=metadata
-            )
-
-        return tool_output
-
-    def subject_to_question(
-        self,
-        text: str,
-        number_of_questions: int,
-        with_analysis: bool = False,
-        output_lang: str | None = None,
-        user_prompt: str | None = None,
-        temperature: float | None = 0.0,
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        validator: Callable[[Any], bool] | None = None,
-        max_validation_retries: int | None = None,
-        priority: int | None = None,
-    ) -> ToolOutput:
-        """
-        Generate a list of questions about a subject.
-
-        Arguments:
-            text: The subject text to generate questions about
-            number_of_questions: Number of questions to generate
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
-            user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
-            logprobs: Whether to return token probability information
-            top_logprobs: Number of top token alternatives to return if logprobs enabled
-            validator: Custom validation function to validate the output
-            max_validation_retries: Maximum number of retry attempts if validation fails
-            priority: Task execution priority (if enabled by vLLM and the model)
-
-        Returns:
-            ToolOutput
-        """
-        tool_name = "subject_to_question"
-        start = perf_counter()
-
-        try:
-            operator_output = 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,
@@ -653,8 +580,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 tool_name=tool_name,
-                output_model=ReasonListStr,
-                mode=None,
+                output_model=Str,
             )
 
             metadata = ToolOutputMetadata(
@@ -689,14 +615,14 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Summarize the given subject text.
+        Summarize the given text
 
         Arguments:
             text: The input text
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -749,7 +675,7 @@ class TheTool:
     def translate(
         self,
         text: str,
-        target_language: str,
+        target_lang: str,
         use_chunker: bool = True,
         with_analysis: bool = False,
         user_prompt: str | None = None,
@@ -761,17 +687,17 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Translate text between languages.
+        Translate text between languages
 
         Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
-            target_language: The target language for translation
-            use_chunker: Whether to use text chunker for text length bigger than 1500
-            with_analysis: Whether to include detailed reasoning analysis
+            target_lang: The target language for translation
+            use_chunker: Whether to use text chunker for large texts
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -786,7 +712,7 @@ class TheTool:
 
         try:
             if len(text.split(" ")) > 1500 and use_chunker:
-                chunks = text_to_chunks(text, 1200, 0)
+                chunks = TheToolUtils.to_chunks(text, 1200, 0)
                 translation = ""
                 analysis = ""
                 logprobs_list = []
@@ -795,7 +721,7 @@ class TheTool:
                     chunk_operator_output = self._operator.run(
                         # User parameters
                         text=chunk,
-                        target_language=target_language,
+                        target_lang=target_lang,
                         with_analysis=with_analysis,
                         user_prompt=user_prompt,
                         temperature=temperature,
@@ -832,7 +758,7 @@ class TheTool:
                 operator_output = self._operator.run(
                     # User parameters
                     text=text,
-                    target_language=target_language,
+                    target_lang=target_lang,
                     with_analysis=with_analysis,
                     user_prompt=user_prompt,
                     temperature=temperature,
@@ -880,16 +806,16 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Proposition input text to meaningful sentences.
+        Convert a text into atomic, independent, meaningful sentences
 
         Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -939,7 +865,7 @@ class TheTool:
 
         return tool_output
 
-    def check_fact(
+    def is_fact(
         self,
         text: str,
         source_text: str,
@@ -954,17 +880,17 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Checks wheather a statement is relevant to the source text or not.
+        Check whether a statement is a fact based on the source text
 
         Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
-            source_text: The source text that we want to check relation of text to it
-            with_analysis: Whether to include detailed reasoning analysis
-            output_lang: Language for the output
+            source_text: The source text
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
+            output_lang: Forces the model to respond in a specific language
             user_prompt: Additional instructions
-            temperature: Controls randomness (0.0 - 2.0)
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output
@@ -974,7 +900,7 @@ class TheTool:
         Returns:
             ToolOutput
         """
-        tool_name = "check_fact"
+        tool_name = "is_fact"
         start = perf_counter()
 
         try:
@@ -1030,15 +956,15 @@ class TheTool:
         priority: int | None = None,
     ) -> ToolOutput:
         """
-        Custom tool that can do almost anything!
+        Custom tool that can do almost anything
 
         Arguments:
             prompt: The user prompt
             output_model: Pydantic BaseModel used for structured output
-            with_analysis: Whether to include detailed reasoning analysis
+            with_analysis: Adds a reasoning step before generating the final output. Note: This doubles token usage per call
             analyze_template: The analyze template used for reasoning analysis
-            output_lang: Language for the output
-            temperature: Controls randomness (0.0 - 2.0)
+            output_lang: Forces the model to respond in a specific language
+            temperature: Controls randomness
             logprobs: Whether to return token probability information
             top_logprobs: Number of top token alternatives to return if logprobs enabled
             validator: Custom validation function to validate the output

hamtaa_texttools-1.3.1.dist-info/RECORD

@@ -1,30 +0,0 @@
-hamtaa_texttools-1.3.1.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
-texttools/__init__.py,sha256=RK1GAU6pq2lGwFtHdrCX5JkPRHmOLGcmGH67hd_7VAQ,175
-texttools/models.py,sha256=5eT2cSrFq8Xa38kANznV7gbi7lwB2PoDxciLKTpsd6c,2516
-texttools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/core/engine.py,sha256=iRHdlIOPuUwIN6_72HNyTQQE7h_7xUZhC-WO-fDA5k8,9597
-texttools/core/exceptions.py,sha256=6SDjUL1rmd3ngzD3ytF4LyTRj3bQMSFR9ECrLoqXXHw,395
-texttools/core/internal_models.py,sha256=aExdLvhXhSev8NY1kuAJckeXdFBEisQtKZPxybd3rW8,1703
-texttools/core/operators/async_operator.py,sha256=wFs7eZ9QJrL0jBOu00YffgfPnIrCSavNjecSorXh-mE,6452
-texttools/core/operators/sync_operator.py,sha256=NaUS-aLh3y0QNMiKut4qtcSZKYXbuPbw0o2jvPsYKdY,6357
-texttools/prompts/categorize.yaml,sha256=42Rp3SgVHaDLKrJ27_uK788LiQud0pOXJthz4r0a40Y,1214
-texttools/prompts/check_fact.yaml,sha256=zWFQDRhEE1ij9wSeeenS9YSTM-bY5zzUaG390zUgmcs,714
-texttools/prompts/extract_entities.yaml,sha256=_zYKHNJDIzVDI_-TnwFCKyMs-XLM5igvmWhvSTc3INQ,637
-texttools/prompts/extract_keywords.yaml,sha256=1o4u3uwzapNtB1BUpNIRL5qtrwjW0Yhvyq0TZJiafdg,3272
-texttools/prompts/is_question.yaml,sha256=jnPARd2ZiulLzHW_r4WAsz3sOryfz6Gy5-yYXp-2hd0,496
-texttools/prompts/merge_questions.yaml,sha256=l9Q2OEjPp3SDkxbq3zZCj2ZmXacWSnmYMpUr3l6r5yE,1816
-texttools/prompts/propositionize.yaml,sha256=nbGAfbm1-2Hoc0JLtqZi-S7VHQfnMmuTKI7dZeBxQW0,1403
-texttools/prompts/rewrite.yaml,sha256=klEm8MqXK-Bo8RsS5R9KLMT0zlD-BKo_G6tz9lpAcEY,5420
-texttools/prompts/run_custom.yaml,sha256=IETY9H0wPGWIIzcnupfbwwKQblwZrbYAxB754W9MhgU,125
-texttools/prompts/subject_to_question.yaml,sha256=AK16pZW9HUppIF8JBSEenbUNOU3aqeVV781_WUXnLqk,1160
-texttools/prompts/summarize.yaml,sha256=rPh060Bx_yI1W2JNg-nr83LUk9itatYLKM8ciH2pOvg,486
-texttools/prompts/text_to_question.yaml,sha256=pUwPgK9l5f8S4E5fCht9JY7PFVK2aY1InPfASr7R5o4,1017
-texttools/prompts/translate.yaml,sha256=Dd5bs3O8SI-FlVSwHMYGeEjMmdOWeRlcfBHkhixCx7c,665
-texttools/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/tools/async_tools.py,sha256=2suwx8N0aRnowaSOpV6C57AqPlmQe5Z0Yx4E5QIMkmU,46939
-texttools/tools/sync_tools.py,sha256=mEuL-nlbxVW30dPE3hGkAUnYXbul-3gN2Le4CMVFCgU,42528
-hamtaa_texttools-1.3.1.dist-info/METADATA,sha256=6wLYAaPVOFpzUz8tN7lfzbAGhEr10JBXgRHcZZvrt5s,7453
-hamtaa_texttools-1.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-1.3.1.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-1.3.1.dist-info/RECORD,,