hamtaa-texttools 1.1.20__py3-none-any.whl → 1.1.21__py3-none-any.whl

texttools/internals/prompt_loader.py

@@ -12,20 +12,12 @@ class PromptLoader:
     Responsibilities:
     - Load and parse YAML prompt definitions.
     - Select the right template (by mode, if applicable).
-    - Inject variables (`{input}`, plus any extra kwargs) into the templates.
+    - Inject variables (`{text}`, plus any extra kwargs) into the templates.
     """
 
     MAIN_TEMPLATE = "main_template"
     ANALYZE_TEMPLATE = "analyze_template"
 
-    @staticmethod
-    def _build_format_args(text: str, **extra_kwargs) -> dict[str, str]:
-        # Base formatting args
-        format_args = {"input": text}
-        # Merge extras
-        format_args.update(extra_kwargs)
-        return format_args
-
     # Use lru_cache to load each file once
     @lru_cache(maxsize=32)
     def _load_templates(self, prompt_file: str, mode: str | None) -> dict[str, str]:
@@ -69,16 +61,6 @@ class PromptLoader:
                     + (f" for mode '{mode}'" if mode else "")
                 )
 
-            if (
-                not analyze_template
-                or not analyze_template.strip()
-                or analyze_template.strip() in ["{analyze_template}", "{}"]
-            ):
-                raise PromptError(
-                    "analyze_template cannot be empty"
-                    + (f" for mode '{mode}'" if mode else "")
-                )
-
             return {
                 self.MAIN_TEMPLATE: main_template,
                 self.ANALYZE_TEMPLATE: analyze_template,
@@ -94,7 +76,8 @@ class PromptLoader:
     ) -> dict[str, str]:
         try:
             template_configs = self._load_templates(prompt_file, mode)
-            format_args = self._build_format_args(text, **extra_kwargs)
+            format_args = {"text": text}
+            format_args.update(extra_kwargs)
 
             # Inject variables inside each template
             for key in template_configs.keys():

texttools/internals/sync_operator.py

@@ -1,11 +1,10 @@
 from typing import TypeVar, Type
 from collections.abc import Callable
-import logging
 
 from openai import OpenAI
 from pydantic import BaseModel
 
-from texttools.internals.models import ToolOutput
+from texttools.internals.models import OperatorOutput
 from texttools.internals.operator_utils import OperatorUtils
 from texttools.internals.prompt_loader import PromptLoader
 from texttools.internals.exceptions import (
@@ -18,35 +17,23 @@ from texttools.internals.exceptions import (
 # Base Model type for output models
 T = TypeVar("T", bound=BaseModel)
 
-logger = logging.getLogger("texttools.sync_operator")
-
 
 class Operator:
     """
-    Core engine for running text-processing operations with an LLM (Sync).
-
-    It wires together:
-    - `PromptLoader` → loads YAML prompt templates.
-    - `UserMergeFormatter` → applies formatting to messages (e.g., merging).
-    - OpenAI client → executes completions/parsed completions.
+    Core engine for running text-processing operations with an LLM.
     """
 
     def __init__(self, client: OpenAI, model: str):
         self._client = client
         self._model = model
 
-    def _analyze(self, prompt_configs: dict[str, str], temperature: float) -> str:
-        """
-        Calls OpenAI API for analysis using the configured prompt template.
-        Returns the analyzed content as a string.
-        """
+    def _analyze_completion(self, analyze_prompt: str, temperature: float) -> str:
         try:
-            analyze_prompt = prompt_configs["analyze_template"]
-
             if not analyze_prompt:
                 raise PromptError("Analyze template is empty")
 
-            analyze_message = [OperatorUtils.build_user_message(analyze_prompt)]
+            analyze_message = OperatorUtils.build_user_message(analyze_prompt)
+
             completion = self._client.chat.completions.create(
                 model=self._model,
                 messages=analyze_message,
@@ -61,7 +48,7 @@ class Operator:
             if not analysis:
                 raise LLMError("Empty analysis response")
 
-            return analysis.strip()
+            return analysis
 
         except Exception as e:
             if isinstance(e, (PromptError, LLMError)):
@@ -70,21 +57,23 @@ class Operator:
 
     def _parse_completion(
         self,
-        message: list[dict[str, str]],
+        main_prompt: str,
         output_model: Type[T],
         temperature: float,
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-        priority: int | None = 0,
+        logprobs: bool,
+        top_logprobs: int,
+        priority: int,
     ) -> tuple[T, object]:
         """
         Parses a chat completion using OpenAI's structured output format.
         Returns both the parsed object and the raw completion for logprobs.
         """
         try:
+            main_message = OperatorUtils.build_user_message(main_prompt)
+
             request_kwargs = {
                 "model": self._model,
-                "messages": message,
+                "messages": main_message,
                 "response_format": output_model,
                 "temperature": temperature,
             }
@@ -92,8 +81,10 @@ class Operator:
             if logprobs:
                 request_kwargs["logprobs"] = True
                 request_kwargs["top_logprobs"] = top_logprobs
+
             if priority:
                 request_kwargs["extra_body"] = {"priority": priority}
+
             completion = self._client.beta.chat.completions.parse(**request_kwargs)
 
             if not completion.choices:
@@ -120,24 +111,22 @@ class Operator:
         user_prompt: str | None,
         temperature: float,
         logprobs: bool,
-        top_logprobs: int | None,
+        top_logprobs: int,
         validator: Callable[[object], bool] | None,
         max_validation_retries: int | None,
+        priority: int,
         # Internal parameters
         prompt_file: str,
         output_model: Type[T],
         mode: str | None,
-        priority: int | None = 0,
         **extra_kwargs,
-    ) -> ToolOutput:
+    ) -> OperatorOutput:
         """
         Execute the LLM pipeline with the given input text. (Sync)
         """
         try:
             prompt_loader = PromptLoader()
-            output = ToolOutput()
 
-            # Prompt configs contain two keys: main_template and analyze template, both are string
             prompt_configs = prompt_loader.load(
                 prompt_file=prompt_file,
                 text=text.strip(),
@@ -145,47 +134,32 @@ class Operator:
                 **extra_kwargs,
             )
 
-            messages = []
+            main_prompt = ""
+            analysis = ""
 
             if with_analysis:
-                analysis = self._analyze(prompt_configs, temperature)
-                messages.append(
-                    OperatorUtils.build_user_message(
-                        f"Based on this analysis: {analysis}"
-                    )
+                analysis = self._analyze_completion(
+                    prompt_configs["analyze_template"], temperature
                 )
+                main_prompt += f"Based on this analysis:\n{analysis}\n"
 
             if output_lang:
-                messages.append(
-                    OperatorUtils.build_user_message(
-                        f"Respond only in the {output_lang} language."
-                    )
-                )
+                main_prompt += f"Respond only in the {output_lang} language.\n"
 
             if user_prompt:
-                messages.append(
-                    OperatorUtils.build_user_message(
-                        f"Consider this instruction {user_prompt}"
-                    )
-                )
-
-            messages.append(
-                OperatorUtils.build_user_message(prompt_configs["main_template"])
-            )
+                main_prompt += f"Consider this instruction {user_prompt}\n"
 
-            messages = OperatorUtils.user_merge_format(messages)
+            main_prompt += prompt_configs["main_template"]
 
             if logprobs and (not isinstance(top_logprobs, int) or top_logprobs < 2):
                 raise ValueError("top_logprobs should be an integer greater than 1")
 
             parsed, completion = self._parse_completion(
-                messages, output_model, temperature, logprobs, top_logprobs, priority
+                main_prompt, output_model, temperature, logprobs, top_logprobs, priority
             )
 
-            output.result = parsed.result
-
             # Retry logic if validation fails
-            if validator and not validator(output.result):
+            if validator and not validator(parsed.result):
                 if (
                     not isinstance(max_validation_retries, int)
                     or max_validation_retries < 1
@@ -195,17 +169,13 @@ class Operator:
                     )
 
                 succeeded = False
-                for attempt in range(max_validation_retries):
-                    logger.warning(
-                        f"Validation failed, retrying for the {attempt + 1} time."
-                    )
-
-                    # Generate new temperature for retry
+                for _ in range(max_validation_retries):
+                    # Generate a new temperature to retry
                     retry_temperature = OperatorUtils.get_retry_temp(temperature)
 
                     try:
                         parsed, completion = self._parse_completion(
-                            messages,
+                            main_prompt,
                             output_model,
                             retry_temperature,
                             logprobs,
@@ -213,30 +183,26 @@ class Operator:
                             priority=priority,
                         )
 
-                        output.result = parsed.result
-
                         # Check if retry was successful
-                        if validator(output.result):
+                        if validator(parsed.result):
                             succeeded = True
                             break
 
-                    except LLMError as e:
-                        logger.error(f"Retry attempt {attempt + 1} failed: {e}")
+                    except LLMError:
+                        pass
 
                 if not succeeded:
-                    raise ValidationError(
-                        f"Validation failed after {max_validation_retries} retries"
-                    )
-
-            if logprobs:
-                output.logprobs = OperatorUtils.extract_logprobs(completion)
-
-            if with_analysis:
-                output.analysis = analysis
-
-            output.process = prompt_file[:-5]
+                    raise ValidationError("Validation failed after all retries")
+
+            operator_output = OperatorOutput(
+                result=parsed.result,
+                analysis=analysis if with_analysis else None,
+                logprobs=OperatorUtils.extract_logprobs(completion)
+                if logprobs
+                else None,
+            )
 
-            return output
+            return operator_output
 
         except (PromptError, LLMError, ValidationError):
             raise

texttools/prompts/README.md

@@ -15,7 +15,7 @@ This folder contains YAML files for all prompts used in the project. Each file r
 ```yaml
 main_template:
   mode_1: |
-    Your main instructions here with placeholders like {input}.
+    Your main instructions here with placeholders like {text}.
   mode_2: |
     Optional reasoning instructions here.
 
@@ -30,6 +30,6 @@ analyze_template:
 
 ## Guidelines
 1. **Naming**: Use descriptive names for each YAML file corresponding to the tool or task it serves.
-2. **Placeholders**: Use `{input}` or other relevant placeholders to dynamically inject data.
+2. **Placeholders**: Use `{text}` or other relevant placeholders to dynamically inject data.
 3. **Modes**: If using modes, ensure both `main_template` and `analyze_template` contain the corresponding keys.
 4. **Consistency**: Keep formatting consistent across files for easier parsing by scripts.

texttools/prompts/categorize.yaml

@@ -1,77 +1,35 @@
-main_template:
-
-  category_list: |
-    You are an expert classification agent.  
-    You receive a list of categories.
-
-    Your task:
-    - Read all provided categories carefully.
-    - Consider the user query, intent, and task explanation.
-    - Select exactly one category name from the list that best matches the user’s intent.
-    - Return only the category name, nothing else.
-
-    Rules:
-    - Never invent categories that are not in the list.
-    - If multiple categories seem possible, choose the closest match based on the description and user intent.
-    - If descriptions are missing or empty, rely on the category name.
-    - If the correct answer cannot be determined with certainty, choose the most likely one.
-
-    Output format:
-    {{
-    "reason": "Explanation of why the input belongs to the category"
-    "result": "<category_name_only>"
-    }}
-
-    Available categories with their descriptions:
-    {category_list}
-
-    The text that has to be categorized:
-    {input}
-
-  category_tree: |
-    You are an expert classification agent.  
-    You receive a list of categories at the current level of a hierarchical category tree.  
-
-    Your task:
-    - Read all provided categories carefully.
-    - Consider the user query, intent, and task explanation.
-    - Select exactly one category name from the list that best matches the user’s intent.
-    - Return only the category name, nothing else.
-
-    Rules:
-    - Never invent categories that are not in the list.
-    - If multiple categories seem possible, choose the closest match based on the description and user intent.
-    - If descriptions are missing or empty, rely on the category name.
-    - If the correct answer cannot be determined with certainty, choose the most likely one.
-
-    Output format:
-    {{
-    "reason": "Explanation of why the input belongs to the category"
-    "result": "<category_name_only>"
-    }}
-
-    Available categories with their descriptions at this level:
-    {category_list}
-
-    Do not include category descriptions at all. Only write the raw category.
-
-    The text that has to be categorized:
-    {input}
-
-analyze_template:
-
-  category_list: |
-    We want to categorize the given text.
-    To improve categorization, we need an analysis of the text.
-    Analyze the given text and write its main idea and a short analysis of that.
-    Analysis should be very short.
-    Text:
-    {input}
-
-  category_tree: |
-    We want to categorize the given text.
-    To improve categorization, we need an analysis of the text.
-    Analyze the given text and write its main idea and a short analysis of that.
-    Analysis should be very short.
-    Text:
-    {input}
+main_template: |
+  You are an expert classification agent.  
+  You receive a list of categories.
+
+  Your task:
+  - Read all provided categories carefully.
+  - Consider the user query, intent, and task explanation.
+  - Select exactly one category name from the list that best matches the user’s intent.
+  - Return only the category name, nothing else.
+
+  Rules:
+  - Never invent categories that are not in the list.
+  - If multiple categories seem possible, choose the closest match based on the description and user intent.
+  - If descriptions are missing or empty, rely on the category name.
+  - If the correct answer cannot be determined with certainty, choose the most likely one.
+
+  Output format:
+  {{
+  "reason": "Explanation of why the input belongs to the category"
+  "result": "<category_name_only>"
+  }}
+
+  Available categories with their descriptions:
+  {category_list}
+
+  The text that has to be categorized:
+  {text}
+
+analyze_template: |
+  We want to categorize the given text.
+  To improve categorization, we need an analysis of the text.
+  Analyze the given text and write its main idea and a short analysis of that.
+  Analysis should be very short.
+  Text:
+  {text}

texttools/prompts/check_fact.yaml

@@ -5,7 +5,7 @@ main_template: |
   Respond only in JSON format (Output should be a boolean):
   {{"result": True/False}}
   The statement is:
-  {input}
+  {text}
   The source text is:
   {source_text}
 
@@ -14,6 +14,6 @@ analyze_template: |
   summarized analysis that could help in determining that can the statement
   be concluded from the source or not.
   The statement is:
-  {input}
+  {text}
   The source text is:
   {source_text}

texttools/prompts/extract_entities.yaml

@@ -12,9 +12,9 @@ main_template: |
     ]
   }}
   Here is the text:
-  {input}
+  {text}
 
 analyze_template: |
   Read the following text and identify any proper nouns, key concepts, or specific mentions that might represent named entities.
   Provide a brief, summarized analysis that could help in categorizing these entities.
-  {input}
+  {text}

texttools/prompts/extract_keywords.yaml

@@ -12,7 +12,7 @@ main_template:
     - Respond only in JSON format:
     {{"result": ["keyword1", "keyword2", etc.]}}
     Here is the text:
-    {input}
+    {text}
 
   threshold: |
     You are an expert keyword extractor specialized in fine-grained concept identification.
@@ -32,7 +32,7 @@ main_template:
     - Respond only in JSON format:
     {{"result": ["keyword1", "keyword2", etc.]}}
     Here is the text:
-    {input}
+    {text}
 
   count: |
     You are an expert keyword extractor with precise output requirements.
@@ -49,20 +49,20 @@ main_template:
     {{"result": ["keyword1", "keyword2", "keyword3", ...]}}
     
     Here is the text:
-    {input}
+    {text}
 
 analyze_template:
   auto: |
     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}
+    {text}
 
   threshold: |
     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}
+    {text}
 
   count: |
     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}
+    {text}

texttools/prompts/is_question.yaml

@@ -4,11 +4,11 @@ main_template: |
   Respond only in JSON format (Output should be a boolean):
   {{"result": True/False}}
   Here is the text:
-  {input}
+  {text}
 
 analyze_template: |
   We want to analyze this text snippet to see if it contains any question or request of some kind or not.
   Read the text, and reason about it being a request or not.
   Summerized, short answer.
-  {input}
+  {text}
   

texttools/prompts/merge_questions.yaml

@@ -12,7 +12,7 @@ main_template:
     - Respond only in JSON format:
     {{"result": "string"}}
     Here is the questions:
-    {input}
+    {text}
 
   reason: |
     You are an AI assistant helping to unify semantically similar questions.
@@ -23,7 +23,7 @@ main_template:
     Respond only in JSON format:
     {{"result": "string"}}
     Here is the questions:
-    {input}
+    {text}
 
 analyze_template:
 
@@ -34,7 +34,7 @@ analyze_template:
     Provide a brief, summarized understanding of the questions' meaning that
     will help in merging and rephrasing it accurately without changing its intent.        
     Here is the question:
-    {input}
+    {text}
 
   reason: |
     Analyze the following questions to identify their exact wording, phrasing,
@@ -42,5 +42,5 @@ analyze_template:
     Provide a brief, summarized analysis of their linguistic structure and current meaning,
     which will then be used to create a new question containing all of their contents.
     Here is the question:
-    {input}
+    {text}
     

texttools/prompts/propositionize.yaml

@@ -12,11 +12,11 @@ main_template: |
   4. No Redundancy: Do not extract summary statements that merely repeat facts already listed.
 
   Extract the atomic propositions from the following text:
-  {input}
+  {text}
 
 analyze_template: |
   We want to analyze this text snippet and think about where we can split sentence to atomic meaningful propositions.
   An atomic proposition is a single, self-contained fact that is concise,
   verifiable, and does not rely on external context.
   You just have to think around the possible propositions in the text and how a proposition can be made.
-  {input}
+  {text}

texttools/prompts/rewrite.yaml

@@ -18,7 +18,7 @@ main_template:
     {{"result": "str"}}
 
     Anchor Text:
-    "{input}"
+    "{text}"
 
   negative: |
     You are an AI assistant designed to generate high-quality training data for semantic text embedding models.
@@ -35,7 +35,7 @@ main_template:
     {{"result": "str"}}
 
     Anchor Text:
-    "{input}"
+    "{text}"
 
   hard_negative: |
       You are an AI assistant designed to generate high-quality training data for semantic text embedding models.
@@ -57,7 +57,7 @@ main_template:
       {{"result": "str"}}
 
       Anchor Text:
-      "{input}"
+      "{text}"
 
 
 analyze_template:
@@ -74,7 +74,7 @@ analyze_template:
     Your analysis should capture the ESSENTIAL MEANING that must be preserved in any paraphrase.
     
     Text:
-    {input}
+    {text}
 
   negative: |
     Analyze the following text to identify its SPECIFIC TOPIC and DOMAIN for creating a high-quality NEGATIVE sample.
@@ -88,7 +88,7 @@ analyze_template:
     The goal is to find topics that are in the same domain but semantically unrelated to this specific text.
     
     Text:
-    {input}
+    {text}
 
   hard_negative: |
     Analyze this text to identify EXACTLY ONE ELEMENT that can be changed to create a hard-negative sample.
@@ -107,5 +107,5 @@ analyze_template:
     - 80-90% of the vocabulary
     
     Text:
-    {input}
+    {text}
     

texttools/prompts/run_custom.yaml

@@ -1,5 +1,5 @@
 main_template: |
-  {input}
+  {text}
   Respond only in JSON format:
   {output_model_str}
 

texttools/prompts/subject_to_question.yaml

@@ -9,7 +9,7 @@ main_template: |
   Respond only in JSON format:
   {{"result": ["question1", "question2", ...], "reason": "string"}}
   Here is the text:
-  {input}
+  {text}
 
 analyze_template: |
   Our goal is to generate questions from the given subject.
@@ -19,4 +19,4 @@ analyze_template: |
   What is the subject about?
   What point of views can we see and generate questoins from it? (Questions that real users might have.)
   Here is the subject:
-  {input}
+  {text}

texttools/prompts/summarize.yaml

@@ -4,11 +4,11 @@ main_template: |
   Respond only in JSON format:
   {{"result": "string"}}
   Provide a concise summary of the following text:
-  {input}
+  {text}
 
 
 analyze_template: |
   Read the following text and identify its main points, key arguments, and overall purpose.
   Provide a brief, summarized analysis that will help in generating an accurate and concise summary.
-  {input}
+  {text}
   

texttools/prompts/text_to_question.yaml

@@ -9,7 +9,7 @@ main_template: |
   Respond only in JSON format:
   {{"result": ["question1", "question2", ...], "reason": "string"}}
   Here is the answer:
-  {input}
+  {text}
   
 analyze_template: |
   Analyze the following answer to identify its key facts,
@@ -18,5 +18,5 @@ analyze_template: |
   help in formulating relevant and direct questions.
   Just mention the keypoints that was provided in the answer
   Here is the answer:
-  {input}
+  {text}