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

texttools/tools/sync_tools.py

@@ -1,5 +1,5 @@
 from datetime import datetime
-from typing import Literal, Any
+from typing import Literal
 from collections.abc import Callable
 
 from openai import OpenAI
@@ -12,6 +12,7 @@ from texttools.internals.exceptions import (
     LLMError,
     ValidationError,
 )
+from texttools.internals.text_to_chunks import text_to_chunks
 
 
 class TheTool:
@@ -35,15 +36,17 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         mode: Literal["category_list", "category_tree"] = "category_list",
-        validator: Callable[[Any], bool] | None = None,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
         """
         Categorize a text into a category / category tree.
 
+        Important Note: category_tree mode is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
             text: The input text to categorize
             categories: The category / category_tree to give to LLM
@@ -73,11 +76,11 @@ class TheTool:
             start = datetime.now()
 
             if mode == "category_tree":
-                # Initializations
-                output = Models.ToolOutput()
                 levels = categories.get_level_count()
                 parent_id = 0
-                final_output = []
+                final_categories = []
+                analysis = ""
+                logprobs = []
 
                 for _ in range(levels):
                     # Get child nodes for current parent
@@ -100,7 +103,7 @@ class TheTool:
                     ]
                     category_names = [node.name for node in children]
 
-                    # Run categorization for this level
+                    # Run categorization for current level
                     level_output = self._operator.run(
                         # User parameters
                         text=text,
@@ -141,16 +144,22 @@ class TheTool:
                         return output
 
                     parent_id = parent_node.node_id
-                    final_output.append(parent_node.name)
+                    final_categories.append(parent_node.name)
 
-                    # Copy analysis/logprobs/process from the last level's output
-                    output.analysis = level_output.analysis
-                    output.logprobs = level_output.logprobs
-                    output.process = level_output.process
+                    if with_analysis:
+                        analysis += level_output.analysis
+                    if logprobs:
+                        logprobs += level_output.logprobs
 
-                output.result = final_output
                 end = datetime.now()
-                output.execution_time = (end - start).total_seconds()
+                output = Models.ToolOutput(
+                    result=final_categories,
+                    logprobs=logprobs,
+                    analysis=analysis,
+                    process="categorize",
+                    execution_time=(end - start).total_seconds(),
+                )
+
                 return output
 
             else:
@@ -197,10 +206,10 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         mode: Literal["auto", "threshold", "count"] = "auto",
         number_of_keywords: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -249,7 +258,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="extract_keywords.yaml",
-                output_model=Models.ListStrOutput,
+                output_model=Models.ListStr,
             )
             end = datetime.now()
             output.execution_time = (end - start).total_seconds()
@@ -271,13 +280,14 @@ class TheTool:
     def extract_entities(
         self,
         text: str,
+        entities: list[str] | 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 | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -286,6 +296,7 @@ class TheTool:
 
         Arguments:
             text: The input text to extract entities from
+            entities: List of entities provided by user (Optional)
             with_analysis: Whether to include detailed reasoning analysis
             output_lang: Language for the output response
             user_prompt: Additional instructions for entity extraction
@@ -313,6 +324,8 @@ class TheTool:
             output = self._operator.run(
                 # User parameters
                 text=text,
+                entities=entities
+                or "all named entities (e.g., PER, ORG, LOC, DAT, etc.)",
                 with_analysis=with_analysis,
                 output_lang=output_lang,
                 user_prompt=user_prompt,
@@ -324,7 +337,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="extract_entities.yaml",
-                output_model=Models.ListDictStrStrOutput,
+                output_model=Models.ListDictStrStr,
                 mode=None,
             )
             end = datetime.now()
@@ -351,8 +364,8 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -397,7 +410,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="is_question.yaml",
-                output_model=Models.BoolOutput,
+                output_model=Models.Bool,
                 mode=None,
                 output_lang=None,
             )
@@ -421,13 +434,14 @@ class TheTool:
     def text_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 | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -436,6 +450,7 @@ class TheTool:
 
         Arguments:
             text: The input text to generate a question from
+            number_of_questions: Number of questions to generate
             with_analysis: Whether to include detailed reasoning analysis
             output_lang: Language for the output question
             user_prompt: Additional instructions for question generation
@@ -463,6 +478,7 @@ class TheTool:
             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,
@@ -474,7 +490,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="text_to_question.yaml",
-                output_model=Models.StrOutput,
+                output_model=Models.ReasonListStr,
                 mode=None,
             )
             end = datetime.now()
@@ -502,9 +518,9 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         mode: Literal["default", "reason"] = "default",
-        validator: Callable[[Any], bool] | None = None,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -553,7 +569,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="merge_questions.yaml",
-                output_model=Models.StrOutput,
+                output_model=Models.Str,
                 mode=mode,
             )
             end = datetime.now()
@@ -581,9 +597,9 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
+        top_logprobs: int = 3,
         mode: Literal["positive", "negative", "hard_negative"] = "positive",
-        validator: Callable[[Any], bool] | None = None,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -631,7 +647,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="rewrite.yaml",
-                output_model=Models.StrOutput,
+                output_model=Models.Str,
                 mode=mode,
             )
             end = datetime.now()
@@ -660,8 +676,8 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -710,7 +726,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="subject_to_question.yaml",
-                output_model=Models.ReasonListStrOutput,
+                output_model=Models.ReasonListStr,
                 mode=None,
             )
             end = datetime.now()
@@ -738,8 +754,8 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
@@ -786,7 +802,7 @@ class TheTool:
                 priority=priority,
                 # Internal parameters
                 prompt_file="summarize.yaml",
-                output_model=Models.StrOutput,
+                output_model=Models.Str,
                 mode=None,
             )
             end = datetime.now()
@@ -810,21 +826,25 @@ class TheTool:
         self,
         text: str,
         target_language: str,
+        use_chunker: bool = True,
         with_analysis: bool = False,
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
         """
         Translate text between languages.
 
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
             text: The input text to translate
             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
             user_prompt: Additional instructions for translation
             temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
@@ -848,27 +868,81 @@ class TheTool:
 
         try:
             start = datetime.now()
-            output = self._operator.run(
-                # User parameters
-                text=text,
-                target_language=target_language,
-                with_analysis=with_analysis,
-                user_prompt=user_prompt,
-                temperature=temperature,
-                logprobs=logprobs,
-                top_logprobs=top_logprobs,
-                validator=validator,
-                max_validation_retries=max_validation_retries,
-                priority=priority,
-                # Internal parameters
-                prompt_file="translate.yaml",
-                output_model=Models.StrOutput,
-                mode=None,
-                output_lang=None,
-            )
-            end = datetime.now()
-            output.execution_time = (end - start).total_seconds()
-            return output
+
+            if len(text.split(" ")) > 1500 and use_chunker:
+                chunks = text_to_chunks(text, 1200, 0)
+
+                translation = ""
+                analysis = ""
+                logprobs = []
+
+                # Run translation for each chunk
+                for chunk in chunks:
+                    chunk_output = self._operator.run(
+                        # User parameters
+                        text=chunk,
+                        target_language=target_language,
+                        with_analysis=with_analysis,
+                        user_prompt=user_prompt,
+                        temperature=temperature,
+                        logprobs=logprobs,
+                        top_logprobs=top_logprobs,
+                        validator=validator,
+                        max_validation_retries=max_validation_retries,
+                        priority=priority,
+                        # Internal parameters
+                        prompt_file="translate.yaml",
+                        output_model=Models.Str,
+                        mode=None,
+                        output_lang=None,
+                    )
+
+                    # Check for errors from operator
+                    if chunk_output.errors:
+                        output.errors.extend(chunk_output.errors)
+                        end = datetime.now()
+                        output.execution_time = (end - start).total_seconds()
+                        return output
+
+                    # Concatenate the outputs
+                    translation += chunk_output.result + "\n"
+                    if with_analysis:
+                        analysis += chunk_output.analysis
+                    if logprobs:
+                        logprobs += chunk_output.logprobs
+
+                end = datetime.now()
+                output = Models.ToolOutput(
+                    result=translation,
+                    logprobs=logprobs,
+                    analysis=analysis,
+                    process="translate",
+                    execution_time=(end - start).total_seconds(),
+                )
+                return output
+
+            else:
+                output = self._operator.run(
+                    # User parameters
+                    text=text,
+                    target_language=target_language,
+                    with_analysis=with_analysis,
+                    user_prompt=user_prompt,
+                    temperature=temperature,
+                    logprobs=logprobs,
+                    top_logprobs=top_logprobs,
+                    validator=validator,
+                    max_validation_retries=max_validation_retries,
+                    priority=priority,
+                    # Internal parameters
+                    prompt_file="translate.yaml",
+                    output_model=Models.Str,
+                    mode=None,
+                    output_lang=None,
+                )
+                end = datetime.now()
+                output.execution_time = (end - start).total_seconds()
+                return output
 
         except PromptError as e:
             output.errors.append(f"Prompt error: {e}")
@@ -883,7 +957,7 @@ class TheTool:
 
         return output
 
-    def detect_entity(
+    def propositionize(
         self,
         text: str,
         with_analysis: bool = False,
@@ -891,13 +965,15 @@ class TheTool:
         user_prompt: str | None = None,
         temperature: float | None = 0.0,
         logprobs: bool = False,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
         """
-        Detects entities in a given text based on the entity_detector.yaml prompt.
+        Proposition input text to meaningful sentences.
+
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
 
         Arguments:
             text: The input text
@@ -913,7 +989,7 @@ class TheTool:
 
         Returns:
             ToolOutput: Object containing:
-                - result (list[Entity]): The entities
+                - result (list[str]): The propositions
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
                 - process (str | None): Description of the process used
@@ -938,8 +1014,8 @@ class TheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="detect_entity.yaml",
-                output_model=Models.EntityDetectorOutput,
+                prompt_file="propositionize.yaml",
+                output_model=Models.ListStr,
                 mode=None,
             )
             end = datetime.now()
@@ -959,24 +1035,28 @@ class TheTool:
 
         return output
 
-    def propositionize(
+    def check_fact(
         self,
         text: str,
+        source_text: str,
         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 | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
         """
-        Proposition input text to meaningful sentences.
+        Checks wheather a statement is relevant to the source text or not.
+
+        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 summary
             user_prompt: Additional instructions for summarization
@@ -989,7 +1069,7 @@ class TheTool:
 
         Returns:
             ToolOutput: Object containing:
-                - result (list[str]): The propositions
+                - result (bool): statement is relevant to source text or not
                 - logprobs (list | None): Probability data if logprobs enabled
                 - analysis (str | None): Detailed reasoning if with_analysis enabled
                 - process (str | None): Description of the process used
@@ -998,7 +1078,6 @@ class TheTool:
                 - errors (list(str) | None): Errors occured during tool call
         """
         output = Models.ToolOutput()
-
         try:
             start = datetime.now()
             output = self._operator.run(
@@ -1014,9 +1093,10 @@ class TheTool:
                 max_validation_retries=max_validation_retries,
                 priority=priority,
                 # Internal parameters
-                prompt_file="propositionize.yaml",
-                output_model=Models.ListStrOutput,
+                prompt_file="check_fact.yaml",
+                output_model=Models.Bool,
                 mode=None,
+                source_text=source_text,
             )
             end = datetime.now()
             output.execution_time = (end - start).total_seconds()
@@ -1038,20 +1118,27 @@ class TheTool:
     def run_custom(
         self,
         prompt: str,
-        output_model: Any,
+        output_model: object,
+        with_analysis: bool = False,
+        analyze_template: str | None = None,
         output_lang: str | None = None,
         temperature: float | None = None,
         logprobs: bool | None = None,
-        top_logprobs: int | None = None,
-        validator: Callable[[Any], bool] | None = None,
+        top_logprobs: int = 3,
+        validator: Callable[[object], bool] | None = None,
         max_validation_retries: int | None = None,
         priority: int | None = 0,
     ) -> Models.ToolOutput:
         """
         Custom tool that can do almost anything!
 
+        Important Note: This tool is EXPERIMENTAL, you can use it but it isn't reliable.
+
         Arguments:
-            text: The user prompt
+            prompt: The user prompt
+            output_model: Pydantic BaseModel used for structured output
+            with_analysis: Whether to include detailed reasoning analysis
+            analyze_template: The analyze template used for reasoning analysis
             output_lang: Language for the output summary
             temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
             logprobs: Whether to return token probability information
@@ -1078,6 +1165,8 @@ class TheTool:
                 # User paramaeters
                 text=prompt,
                 output_model=output_model,
+                with_analysis=with_analysis,
+                analyze_template=analyze_template,
                 output_model_str=output_model.model_json_schema(),
                 output_lang=output_lang,
                 temperature=temperature,
@@ -1089,7 +1178,6 @@ class TheTool:
                 # Internal parameters
                 prompt_file="run_custom.yaml",
                 user_prompt=None,
-                with_analysis=False,
                 mode=None,
             )
             end = datetime.now()

hamtaa_texttools-1.1.18.dist-info/RECORD

@@ -1,33 +0,0 @@
-hamtaa_texttools-1.1.18.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
-texttools/__init__.py,sha256=CmCS9dEvO6061GiJ8A7gD3UAhCWHTkaID9q3Krlyq_o,311
-texttools/batch/batch_config.py,sha256=m1UgILVKjNdWE6laNbfbG4vgi4o2fEegGZbeoam6pnY,749
-texttools/batch/batch_runner.py,sha256=Tz-jec27UZBSZAXc0sxitc5XycDfzvOYl47Yqzq6Myw,10031
-texttools/batch/internals/batch_manager.py,sha256=UoBe76vmFG72qrSaGKDZf4HzkykFBkkkbL9TLfV8TuQ,8730
-texttools/batch/internals/utils.py,sha256=F1_7YlVFKhjUROAFX4m0SaP8KiZVZyHRMIIB87VUGQc,373
-texttools/internals/async_operator.py,sha256=_RfYSm_66RJ6nppzorJ4r3BHdhr8xr404QjeVvsvX4Q,8485
-texttools/internals/exceptions.py,sha256=h_yp_5i_5IfmqTBQ4S6ZOISrrliJBQ3HTEAjwJXrplk,495
-texttools/internals/formatters.py,sha256=tACNLP6PeoqaRpNudVxBaHA25zyWqWYPZQuYysIu88g,941
-texttools/internals/models.py,sha256=zmgdFhMCNyfc-5dtSE4jwulhltVgxYzITZRMDJBUF0A,5977
-texttools/internals/operator_utils.py,sha256=w1k0RJ_W_CRbVc_J2w337VuL-opHpHiCxfhEOwtyuOo,1856
-texttools/internals/prompt_loader.py,sha256=bL4F0pwVEjaBhjNRbf0kyl0YhSJ0G8NXa03Uz7XBzTE,3030
-texttools/internals/sync_operator.py,sha256=7SdsNoFQxgmMrSZbUUw7SJVqyO5Xhu8dui9lm64RKsk,8382
-texttools/prompts/README.md,sha256=-5YO93CN93QLifqZpUeUnCOCBbDiOTV-cFQeJ7Gg0I4,1377
-texttools/prompts/categorize.yaml,sha256=F7VezB25B_sT5yoC25ezODBddkuDD5lUHKetSpx9FKI,2743
-texttools/prompts/detect_entity.yaml,sha256=1rhMkJOjxSQcT4j_c5SRcIm77AUdeG-rUmeidb6VOFc,981
-texttools/prompts/extract_entities.yaml,sha256=KiKjeDpHaeh3JVtZ6q1pa3k4DYucUIU9WnEcRTCA-SE,651
-texttools/prompts/extract_keywords.yaml,sha256=Vj4Tt3vT6LtpOo_iBZPo9oWI50oVdPGXe5i8yDR8ex4,3177
-texttools/prompts/is_question.yaml,sha256=d0-vKRbXWkxvO64ikvxRjEmpAXGpCYIPGhgexvPPjws,471
-texttools/prompts/merge_questions.yaml,sha256=0J85GvTirZB4ELwH3sk8ub_WcqqpYf6PrMKr3djlZeo,1792
-texttools/prompts/propositionize.yaml,sha256=ZEFkYy8qYpFK2oCmZ-i5M7nFtlQp_q8bKQZbFSuyE3c,792
-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/summarize.yaml,sha256=o6rxGPfWtZd61Duvm8NVvCJqfq73b-wAuMSKR6UYUqY,459
-texttools/prompts/text_to_question.yaml,sha256=UheKYpDn6iyKI8NxunHZtFpNyfCLZZe5cvkuXpurUJY,783
-texttools/prompts/translate.yaml,sha256=mGT2uBCei6uucWqVbs4silk-UV060v3G0jnt0P6sr50,634
-texttools/tools/async_tools.py,sha256=uNy-18XBOGKPcXkvp5mtNYfBrd16qA2HGsoxxMjTpFM,48536
-texttools/tools/sync_tools.py,sha256=UMos-6cWL9LKy8m0UwK8PBZEXqM5RVQgjjQ3k8LL4qA,48348
-hamtaa_texttools-1.1.18.dist-info/METADATA,sha256=Ro8eqilfvMDymdL8N_wkkgshnMPy9nWLJDO_IRBA9J4,9680
-hamtaa_texttools-1.1.18.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-1.1.18.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-1.1.18.dist-info/RECORD,,

texttools/internals/formatters.py

@@ -1,24 +0,0 @@
-class Formatter:
-    @staticmethod
-    def user_merge_format(messages: list[dict[str, str]]) -> list[dict[str, str]]:
-        """
-        Merges consecutive user messages into a single message, separated by newlines.
-
-        This is useful for condensing a multi-turn user input into a single
-        message for the LLM. Assistant and system messages are left unchanged and
-        act as separators between user message groups.
-        """
-        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/detect_entity.yaml

@@ -1,22 +0,0 @@
-main_template: |
-  You are an expert Named Entity Recognition (NER) system. Extract entities from the text.
-  The output must strictly follow the provided Pydantic schema.
-  
-  Mapping Rule:
-  - Person: شخص
-  - Location: مکان
-  - Time: زمان
-  - Living Beings: موجود زنده
-  - Organization: سازمان
-  - Concept: مفهوم
-  
-  CRITICAL:
-  1. The final output structure must be a complete JSON object matching the Pydantic schema (List[Entity]).
-  2. Both the extracted text and the type must be in Persian, using the exact mapping provided above.
-  
-  Here is the text: {input}
-
-analyze_template: |
-  Analyze the following text to identify all potential named entities and their categories (Person, Location, Time, Living Beings, Organization, Concept). 
-  Provide a brief summary of the entities identified that will help the main process to extract them accurately and apply the correct Persian type label.
-  Here is the text: {input}