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

{hamtaa_texttools-1.1.16.dist-info → hamtaa_texttools-1.1.17.dist-info}/METADATA

@@ -1,8 +1,8 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 1.1.16
+Version: 1.1.17
 Summary: 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>
+Author-email: Tohidi <the.mohammad.tohidi@gmail.com>, Montazer <montazerh82@gmail.com>, Givechi <mohamad.m.givechi@gmail.com>, MoosaviNejad <erfanmoosavi84@gmail.com>, Zareshahi <a.zareshahi1377@gmail.com>
 License: MIT License
         
         Copyright (c) 2025 Hamtaa
@@ -60,6 +60,7 @@ Each tool is designed to work with structured outputs (JSON / Pydantic).
 - **`subject_to_question()`** - Generates questions about a specific subject
 - **`summarize()`** - Text summarization
 - **`translate()`** - Text translation between languages
+- **`propositionize()`** - Convert text to atomic independence meaningful sentences 
 - **`run_custom()`** - Allows users to define a custom tool with an arbitrary BaseModel
 
 ---

{hamtaa_texttools-1.1.16.dist-info → hamtaa_texttools-1.1.17.dist-info}/RECORD

@@ -1,4 +1,4 @@
-hamtaa_texttools-1.1.16.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
+hamtaa_texttools-1.1.17.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
 texttools/__init__.py,sha256=dc81lXGWP29k7oVvq2BMoMotz6lgiwX4PO2jHHBe2S8,317
 texttools/batch/batch_config.py,sha256=m1UgILVKjNdWE6laNbfbG4vgi4o2fEegGZbeoam6pnY,749
 texttools/batch/batch_runner.py,sha256=9e4SPLlvLHHs3U7bHkuuMVw8TFNwsGUzRjkAMKN4_ik,9378
@@ -11,21 +11,22 @@ texttools/prompts/extract_entities.yaml,sha256=KiKjeDpHaeh3JVtZ6q1pa3k4DYucUIU9W
 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=vNAg0gxwUZPsMS4q8JCv7RlYymS8l_5FsFI5adEYT7w,34376
-texttools/tools/sync_tools.py,sha256=hFifFa9YatvSeGif2E_bIG006eMdIBr6SV9HsZ_dAlg,34187
+texttools/tools/async_tools.py,sha256=hbFAvBOJ8Pvocxr6cGS8WHFEYnRC6GhmVl_JxCloGhM,40163
+texttools/tools/sync_tools.py,sha256=kUzU3lE5ZWeBNXvmQqqVC8HWr745eOui7oZlW3-7mJo,39964
 texttools/tools/internals/async_operator.py,sha256=1TMr8e1qbE9GSz8jl0q3MKdM8lIYE-1ZuSxHjYPqKHI,7198
 texttools/tools/internals/formatters.py,sha256=tACNLP6PeoqaRpNudVxBaHA25zyWqWYPZQuYysIu88g,941
-texttools/tools/internals/models.py,sha256=2QnvMiijuSqOqpCl026848rJy_pHNbRoDESlQvcdHlk,5839
+texttools/tools/internals/models.py,sha256=lbhwH8FMwKkLnIOqu4jK3HNv4q_CrY9w3QQ_stlPs1Y,5961
 texttools/tools/internals/operator_utils.py,sha256=w1k0RJ_W_CRbVc_J2w337VuL-opHpHiCxfhEOwtyuOo,1856
 texttools/tools/internals/prompt_loader.py,sha256=4g6-U8kqrGN7VpNaRcrBcnF-h03PXjUDBP0lL0_4EZY,1953
 texttools/tools/internals/sync_operator.py,sha256=4-V__o55Q8w29lWxkhG4St-exZLZTfBbiW76knOXbc0,7106
-hamtaa_texttools-1.1.16.dist-info/METADATA,sha256=DL-cjlGMv7bft8QVd-pn5E_tNDuPgQHkTKGl4YTosGw,9555
-hamtaa_texttools-1.1.16.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-1.1.16.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-1.1.16.dist-info/RECORD,,
+hamtaa_texttools-1.1.17.dist-info/METADATA,sha256=2h8GKwr3HKsaW10OKofe_JMZDD7Jas9cdvFFEwFCS_M,9680
+hamtaa_texttools-1.1.17.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+hamtaa_texttools-1.1.17.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
+hamtaa_texttools-1.1.17.dist-info/RECORD,,

texttools/prompts/propositionize.yaml

@@ -0,0 +1,15 @@
+main_template: |
+  You are an expert in breaking down text into atomic propositions in that language.
+  An atomic proposition is a single, self-contained fact that is concise, verifiable,
+  and does not rely on external context.
+  Each proposition must stand alone.
+  Rewrite sentences if needed to keep the context saved in each sentence.
+  Extract the atomic propositions of this text:
+  {input}
+
+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}

texttools/tools/async_tools.py

@@ -62,6 +62,9 @@ class AsyncTheTool:
                 - result (str): The assigned category
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -75,8 +78,8 @@ class AsyncTheTool:
 
             for _ in range(levels):
                 # Get child nodes for current parent
-                parent_node = categories.find_node(parent_id)
-                children = categories.find_children(parent_node)
+                parent_node = categories.get_node(parent_id)
+                children = categories.get_children(parent_node)
 
                 # Check if child nodes exist
                 if not children:
@@ -124,7 +127,7 @@ class AsyncTheTool:
                 chosen_category = level_output.result
 
                 # Find the corresponding node
-                parent_node = categories.find_node(chosen_category)
+                parent_node = categories.get_node(chosen_category)
                 if parent_node is None:
                     output.errors.append(
                         f"Category '{chosen_category}' not found in tree after selection"
@@ -203,6 +206,9 @@ class AsyncTheTool:
                 - result (list[str]): List of extracted keywords
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -261,6 +267,9 @@ class AsyncTheTool:
                 - result (list[dict]): List of entities with 'text' and 'type' keys
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -316,6 +325,9 @@ class AsyncTheTool:
                 - result (bool): True if text is a question, False otherwise
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -373,6 +385,9 @@ class AsyncTheTool:
                 - result (str): The generated question
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -432,6 +447,9 @@ class AsyncTheTool:
                 - result (str): The merged question
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -492,6 +510,9 @@ class AsyncTheTool:
                 - result (str): The rewritten text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -551,6 +572,9 @@ class AsyncTheTool:
                 - result (list[str]): List of generated questions
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -609,6 +633,9 @@ class AsyncTheTool:
                 - result (str): The summary text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -666,6 +693,9 @@ class AsyncTheTool:
                 - result (str): The translated text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -724,6 +754,9 @@ class AsyncTheTool:
                 - result (list[Entity]): The entities
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -748,6 +781,66 @@ class AsyncTheTool:
         output.execution_time = (end - start).total_seconds()
         return output
 
+    async def propositionize(
+        self,
+        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,
+        max_validation_retries: int | None = None,
+        priority: int | None = 0,
+    ) -> Models.ToolOutput:
+        """
+        Proposition input text to meaningful sentences.
+
+        Arguments:
+            text: The input text
+            with_analysis: Whether to include detailed reasoning analysis
+            output_lang: Language for the output summary
+            user_prompt: Additional instructions for summarization
+            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            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 model)
+
+        Returns:
+            ToolOutput: Object containing:
+                - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
+                - errors (list(str) | None): Errors occured during tool call
+        """
+        start = datetime.now()
+        output = await 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
+            prompt_file="propositionize.yaml",
+            output_model=Models.ListStrOutput,
+            mode=None,
+        )
+        end = datetime.now()
+        output.execution_time = (end - start).total_seconds()
+        return output
+
     async def run_custom(
         self,
         prompt: str,
@@ -778,6 +871,9 @@ class AsyncTheTool:
                 - result (str): The translated text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()

texttools/tools/internals/models.py

@@ -6,19 +6,24 @@ from pydantic import BaseModel, Field, create_model
 
 class ToolOutput(BaseModel):
     result: Any = None
-    analysis: str = ""
     logprobs: list[dict[str, Any]] = []
+    analysis: str = ""
     process: str = ""
     processed_at: datetime = datetime.now()
     execution_time: float = -1.0
     errors: list[str] = []
 
     def __repr__(self) -> str:
-        return f"ToolOutput(process='{self.process}', result_type='{type(self.result)}', result='{self.result}', analysis='{self.analysis}', logprobs='{self.logprobs}', errors='{self.errors}', processed_at='{self.processed_at}', execution_time='{self.execution_time}'"
+        return f"""
+        ToolOutput(process='{self.process}', result_type='{type(self.result)}', 
+        result='{self.result}', analysis='{self.analysis}', 
+        logprobs='{self.logprobs}', errors='{self.errors}', 
+        processed_at='{self.processed_at}', execution_time='{self.execution_time}'
+        """
 
 
 class StrOutput(BaseModel):
-    result: str = Field(..., description="The output string")
+    result: str = Field(..., description="The output string", example="text")
 
 
 class BoolOutput(BaseModel):
@@ -37,13 +42,15 @@ class ListDictStrStrOutput(BaseModel):
     result: list[dict[str, str]] = Field(
         ...,
         description="List of dictionaries containing string key-value pairs",
-        example=[{"text": "Mohammad", "type": "PER"}],
+        example=[{"text": "Mohammad", "type": "PER"}, {"text": "Iran", "type": "LOC"}],
     )
 
 
 class ReasonListStrOutput(BaseModel):
     reason: str = Field(..., description="Thinking process that led to the output")
-    result: list[str] = Field(..., description="The output list of strings")
+    result: list[str] = Field(
+        ..., description="The output list of strings", example=["text_1", "text_2"]
+    )
 
 
 class Node(BaseModel):
@@ -51,14 +58,44 @@ class Node(BaseModel):
     name: str
     level: int
     parent_id: int | None
-    description: str = "No description provided"
+    description: str
 
 
 class CategoryTree:
     def __init__(self, tree_name):
-        self.root = Node(node_id=0, name=tree_name, level=0, parent_id=None)
-        self.all_nodes: list[Node] = [self.root]
-        self.new_id = 1
+        self._root = Node(
+            node_id=0, name=tree_name, level=0, parent_id=None, description="Root node"
+        )
+        self._all_nodes: list[Node] = [self._root]
+        self._new_id = 1
+
+    def get_all_nodes(self) -> list[Node]:
+        return self._all_nodes
+
+    def get_level_count(self) -> int:
+        return max([item.level for item in self._all_nodes])
+
+    def get_node(self, identifier: int | str) -> Node | None:
+        if isinstance(identifier, str):
+            for node in self.get_all_nodes():
+                if node.name == identifier:
+                    return node
+            return None
+        elif isinstance(identifier, int):
+            for node in self.get_all_nodes():
+                if node.node_id == identifier:
+                    return node
+            return None
+        else:
+            return None
+
+    def get_children(self, parent_node: Node) -> list[Node] | None:
+        children = [
+            node
+            for node in self.get_all_nodes()
+            if parent_node.node_id == node.parent_id
+        ]
+        return children if children else None
 
     def add_node(
         self,
@@ -66,12 +103,12 @@ class CategoryTree:
         parent_name: str | None = None,
         description: str | None = None,
     ) -> None:
-        if self.find_node(node_name):
+        if self.get_node(node_name):
             raise ValueError(f"{node_name} has been chosen for another category before")
 
         if parent_name:
-            parent_node = self.find_node(parent_name)
-            if parent_node is None:
+            parent_node = self.get_node(parent_name)
+            if not parent_node:
                 raise ValueError(f"Parent category '{parent_name}' not found")
             parent_id = parent_node.node_id
             level = parent_node.level + 1
@@ -80,61 +117,31 @@ class CategoryTree:
             parent_id = 0
 
         node_data = {
-            "node_id": self.new_id,
+            "node_id": self._new_id,
             "name": node_name,
             "level": level,
             "parent_id": parent_id,
+            "description": description if description else "No description provided",
         }
 
-        if description is not None:
-            node_data["description"] = description
-
-        self.all_nodes.append(Node(**node_data))
-        self.new_id += 1
-
-    def get_nodes(self) -> list[Node]:
-        return self.all_nodes
-
-    def get_level_count(self) -> int:
-        return max([item.level for item in self.all_nodes])
-
-    def find_node(self, identifier: int | str) -> Node | None:
-        if isinstance(identifier, str):
-            for node in self.get_nodes():
-                if node.name == identifier:
-                    return node
-            return None
-        elif isinstance(identifier, int):
-            for node in self.get_nodes():
-                if node.node_id == identifier:
-                    return node
-            return None
-        else:
-            return None
-
-    def find_children(self, parent_node: Node) -> list[Node] | None:
-        children = [
-            node for node in self.get_nodes() if parent_node.node_id == node.parent_id
-        ]
-        return children if children else None
+        self._all_nodes.append(Node(**node_data))
+        self._new_id += 1
 
     def remove_node(self, identifier: int | str) -> None:
-        node = self.find_node(identifier)
+        node = self.get_node(identifier)
 
-        if node is not None:
+        if node:
             # Remove node's children recursively
-            children = self.find_children(node)
+            children = self.get_children(node)
 
-            # Ending condition
-            if children is None:
-                self.all_nodes.remove(node)
+            if not children:
+                self._all_nodes.remove(node)
                 return
 
             for child in children:
                 self.remove_node(child.name)
 
-            # Remove the node from tree
-            self.all_nodes.remove(node)
+            self._all_nodes.remove(node)
         else:
             raise ValueError(f"Node with identifier: '{identifier}' not found.")
 
@@ -142,7 +149,7 @@ class CategoryTree:
         def build_dict(node: Node) -> dict:
             children = [
                 build_dict(child)
-                for child in self.all_nodes
+                for child in self._all_nodes
                 if child.parent_id == node.node_id
             ]
             return {
@@ -153,7 +160,7 @@ class CategoryTree:
                 "children": children,
             }
 
-        return {"category_tree": build_dict(self.root)["children"]}
+        return {"category_tree": build_dict(self._root)["children"]}
 
 
 # This function is needed to create CategorizerOutput with dynamic categories

texttools/tools/sync_tools.py

@@ -60,7 +60,11 @@ class TheTool:
                 - result (str): The assigned category
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
+
         """
         start = datetime.now()
 
@@ -73,8 +77,8 @@ class TheTool:
 
             for _ in range(levels):
                 # Get child nodes for current parent
-                parent_node = categories.find_node(parent_id)
-                children = categories.find_children(parent_node)
+                parent_node = categories.get_node(parent_id)
+                children = categories.get_children(parent_node)
 
                 # Check if child nodes exist
                 if not children:
@@ -123,7 +127,7 @@ class TheTool:
                 chosen_category = level_output.result
 
                 # Find the corresponding node
-                parent_node = categories.find_node(chosen_category)
+                parent_node = categories.get_node(chosen_category)
                 if parent_node is None:
                     output.errors.append(
                         f"Category '{chosen_category}' not found in tree after selection"
@@ -203,6 +207,9 @@ class TheTool:
                 - result (list[str]): List of extracted keywords
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -261,6 +268,9 @@ class TheTool:
                 - result (list[dict]): List of entities with 'text' and 'type' keys
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -316,6 +326,9 @@ class TheTool:
                 - result (bool): True if text is a question, False otherwise
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -373,6 +386,9 @@ class TheTool:
                 - result (str): The generated question
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -432,6 +448,9 @@ class TheTool:
                 - result (str): The merged question
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -492,6 +511,9 @@ class TheTool:
                 - result (str): The rewritten text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -551,6 +573,9 @@ class TheTool:
                 - result (list[str]): List of generated questions
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -609,6 +634,9 @@ class TheTool:
                 - result (str): The summary text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -666,6 +694,9 @@ class TheTool:
                 - result (str): The translated text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -724,6 +755,9 @@ class TheTool:
                 - result (list[Entity]): The entities
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()
@@ -748,6 +782,66 @@ class TheTool:
         output.execution_time = (end - start).total_seconds()
         return output
 
+    def propositionize(
+        self,
+        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,
+        max_validation_retries: int | None = None,
+        priority: int | None = 0,
+    ) -> Models.ToolOutput:
+        """
+        Proposition input text to meaningful sentences.
+
+        Arguments:
+            text: The input text
+            with_analysis: Whether to include detailed reasoning analysis
+            output_lang: Language for the output summary
+            user_prompt: Additional instructions for summarization
+            temperature: Controls randomness (0.0 = deterministic, 1.0 = creative)
+            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 model)
+
+        Returns:
+            ToolOutput: Object containing:
+                - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
+                - errors (list(str) | None): Errors occured during tool call
+        """
+        start = datetime.now()
+        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
+            prompt_file="propositionize.yaml",
+            output_model=Models.ListStrOutput,
+            mode=None,
+        )
+        end = datetime.now()
+        output.execution_time = (end - start).total_seconds()
+        return output
+
     def run_custom(
         self,
         prompt: str,
@@ -778,6 +872,9 @@ class TheTool:
                 - result (str): The translated text
                 - 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
+                - processed_at (datetime): Timestamp when the processing occurred
+                - execution_time (float): Time taken for execution in seconds (-1.0 if not measured)
                 - errors (list(str) | None): Errors occured during tool call
         """
         start = datetime.now()