hamtaa-texttools 0.1.43__tar.gz → 0.1.45__tar.gz

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 0.1.43
+Version: 0.1.45
 Summary: A set of high-level NLP tools
 Author: Tohidi, Montazer, Givechi, Mousavinezhad
 Requires-Python: >=3.8
@@ -20,7 +20,7 @@ Requires-Dist: numpy==1.26.4
 </p>
 
 
-### How to Install
+## How to Install
 
 Install the package using:
 

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/README.md

@@ -10,7 +10,7 @@
 </p>
 
 
-### How to Install
+## How to Install
 
 Install the package using:
 

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/hamtaa_texttools.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hamtaa-texttools
-Version: 0.1.43
+Version: 0.1.45
 Summary: A set of high-level NLP tools
 Author: Tohidi, Montazer, Givechi, Mousavinezhad
 Requires-Python: >=3.8
@@ -20,7 +20,7 @@ Requires-Dist: numpy==1.26.4
 </p>
 
 
-### How to Install
+## How to Install
 
 Install the package using:
 

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/hamtaa_texttools.egg-info/SOURCES.txt

@@ -20,9 +20,6 @@ texttools/base/base_router.py
 texttools/base/base_summarizer.py
 texttools/base/base_task_performer.py
 texttools/base/base_translator.py
-texttools/batch_manager/__init__.py
-texttools/batch_manager/batch_manager.py
-texttools/batch_manager/batch_runner.py
 texttools/formatter/__init__.py
 texttools/formatter/base.py
 texttools/formatter/gemma3_formatter.py
@@ -62,4 +59,8 @@ texttools/tools/summarizer/__init__.py
 texttools/tools/summarizer/gemma_summarizer.py
 texttools/tools/summarizer/llm_summerizer.py
 texttools/tools/translator/__init__.py
-texttools/tools/translator/gemma_translator.py
+texttools/tools/translator/gemma_translator.py
+texttools/utils/flex_processor.py
+texttools/utils/batch_manager/__init__.py
+texttools/utils/batch_manager/batch_manager.py
+texttools/utils/batch_manager/batch_runner.py

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hamtaa-texttools"
-version = "0.1.43"
+version = "0.1.45"
 description = "A set of high-level NLP tools"
 readme = "README.md"
 requires-python = ">=3.8"

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/texttools/__init__.py

@@ -1,4 +1,4 @@
-from texttools.batch_manager import BatchJobRunner, SimpleBatchManager
+from texttools.utils.batch_manager import BatchJobRunner, SimpleBatchManager
 from texttools.handlers import (
     NoOpResultHandler,
     PrintResultHandler,

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/texttools/formatter/gemma3_formatter.py

@@ -1,5 +1,3 @@
-from typing import Literal
-
 from texttools.formatter.base import ChatFormatter
 
 
@@ -10,14 +8,13 @@ class Gemma3Formatter(ChatFormatter):
     """
 
     ROLE = "role"
+    CONTENT = "content"
     USER_ROLE = "user"
     ASSISTANT_ROLE = "assistant"
-    CONTENT = "content"
     VALID_ROLES = {USER_ROLE, ASSISTANT_ROLE}
+    VALID_KEYS = {ROLE, CONTENT}
 
-    def format(
-        self, messages: list[dict[Literal["role", "content"], str]]
-    ) -> list[dict[str, str]]:
+    def format(self, messages: list[dict[str, str]]) -> list[dict[str, str]]:
         """
         :param messages: list of {"role": ..., "content": ...}, where role is "user", "assistant", or "system"
         :return: a new list where consecutive "user" messages are merged into single entries
@@ -25,14 +22,20 @@ class Gemma3Formatter(ChatFormatter):
 
         merged: list[dict[str, str]] = []
 
-        for msg in messages:
-            role, content = msg[self.ROLE], msg[self.CONTENT].strip()
+        for message in messages:
+            # Validate keys strictly
+            if set(message.keys()) != self.VALID_KEYS:
+                raise ValueError(
+                    f"Message dict keys must be exactly {self.VALID_KEYS}, got {set(message.keys())}"
+                )
+
+            role, content = message[self.ROLE], message[self.CONTENT].strip()
 
             # Replace "system" role with "user" role
             if role == "system":
                 role = self.USER_ROLE
 
-            # Raise value error if msg["role"] wan't a valid role
+            # Raise value error if message["role"] wan't a valid role
             if role not in self.VALID_ROLES:
                 raise ValueError(f"Unexpected role: {role}")
 

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/texttools/tools/question_detector/gemma_detector.py

@@ -36,64 +36,48 @@ class GemmaQuestionDetector(BaseQuestionDetector):
         self.model = model
         self.temperature = temperature
         self.client_kwargs = client_kwargs
-
         self.chat_formatter = chat_formatter or Gemma3Formatter()
-
         self.use_reason = use_reason
         self.prompt_template = prompt_template
 
-        self.json_schema = {"is_question": bool}
-
     def _build_messages(self, text: str, reason: str = None) -> list[dict[str, str]]:
-        clean = self.preprocess(text)
-        schema_instr = f"respond only in JSON format: {self.json_schema}"
+        clean_text = self.preprocess(text)
         messages: list[dict[str, str]] = []
 
         if reason:
             messages.append({"role": "user", "content": reason})
 
-        messages.append({"role": "user", "content": schema_instr})
         if self.prompt_template:
             messages.append({"role": "user", "content": self.prompt_template})
-        messages.append({"role": "user", "content": clean})
+        messages.append({"role": "user", "content": clean_text})
 
-        # this line will restructure the messages
-        # based on the formatter that we provided
-        # some models will require custom settings
+        # Restructure the messages based on the formatter; some models will require custom settings
         restructured = self.chat_formatter.format(messages=messages)
 
         return restructured
 
     def _reason(self, text: str) -> list:
-        messages = [
-            {
-                "role": "user",
-                "content": """
-                    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
-                    """,
-            },
-            {
-                "role": "user",
-                "content": f"""
+        reason_prompt = f"""
+                    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
                     {text}
-                    """,
-            },
+                    """
+        messages = [
+            {"role": "user", "content": reason_prompt},
         ]
 
         restructured = self.chat_formatter.format(messages=messages)
 
-        resp = self.client.chat.completions.create(
+        response = self.client.chat.completions.create(
             model=self.model,
             messages=restructured,
             temperature=self.temperature,
             **self.client_kwargs,
         )
 
-        reason = resp.choices[0].message.content.strip()
+        reason = response.choices[0].message.content.strip()
         return reason
 
     def detect(self, text: str) -> bool:
@@ -125,6 +109,6 @@ class GemmaQuestionDetector(BaseQuestionDetector):
                 f"Failed to parse the response. Raw content: {message.content}"
             )
 
-        # dispatch and return
+        # Dispatch and return
         self._dispatch({"question": text, "result": result})
         return result

{hamtaa_texttools-0.1.43 → hamtaa_texttools-0.1.45}/texttools/tools/translator/gemma_translator.py

@@ -1,5 +1,3 @@
-import json
-import re
 from typing import Any, Optional
 
 from openai import OpenAI
@@ -35,7 +33,7 @@ class GemmaTranslator(BaseTranslator):
         **client_kwargs: Any,
     ):
         super().__init__(handlers)
-        self.client = client
+        self.client: OpenAI = client
         self.model = model
         self.temperature = temperature
         self.client_kwargs = client_kwargs
@@ -134,27 +132,16 @@ class GemmaTranslator(BaseTranslator):
         messages.append({"role": "user", "content": text_prompt})
 
         restructured = self.chat_formatter.format(messages=messages)
-        completion = self.client.chat.completions.create(
+        completion = self.client.chat.completions.parse(
             model=self.model,
             messages=restructured,
-            response_format={
-                "type": "json_schema",
-                "json_schema": {
-                    "name": "NER",
-                    "schema": PreprocessorOutput.model_json_schema(),
-                },
-            },
+            response_format=PreprocessorOutput,
             temperature=self.temperature,
-            **self.client_kwargs,
+            extra_body=dict(guided_decoding_backend="auto") ** self.client_kwargs,
         )
-        response = completion.choices[0].message.content
-
-        # Remove Markdown-style triple backticks and any optional language tag like "json"
-        if response.startswith("```"):
-            response = re.sub(r"^```(?:json)?\s*|```$", "", response.strip())
-
-        entities = json.loads(response)
+        message = completion.choices[0].message
 
+        entities = message.parsed
         return entities
 
     def translate(
@@ -189,7 +176,7 @@ class GemmaTranslator(BaseTranslator):
             temperature=self.temperature,
             **self.client_kwargs,
         )
-        response = completion.choices[0].message.content.strip()
+        response = completion.choices[0].message.content
 
         self._dispatch(
             {

hamtaa_texttools-0.1.45/texttools/utils/flex_processor.py

@@ -0,0 +1,78 @@
+import random
+import asyncio
+from openai import OpenAI, RateLimitError, APIError
+from typing import Optional
+from pydantic import BaseModel, ValidationError
+import httpx
+
+# http_client = httpx()
+# test_client = OpenAI(http_client=http_client)
+
+async def flex_processing(
+        LLM_client: OpenAI,
+        system_prompt: str,
+        user_prompt: str,
+        output_model: Optional[BaseModel]=None,
+        prompt_cache_key: Optional[str]=None,
+        max_retries: int = 10,
+        base_delay: float = 2.0,
+        model_name: Optional[str] ="gpt-5-mini",
+        **client_kwargs):
+    """
+    Wrapper for flex processing with retry and exponential backoff.
+    Handles 429 'Resource Unavailable' errors gracefully.
+    """
+    for attempt in range(max_retries):
+        try:
+            request_kwargs = {
+                    "model": model_name,
+                    "messages": [
+                        {"role": "system", "content": system_prompt},
+                        {"role": "user", "content": user_prompt},
+                    ],
+                    "service_tier": "flex",
+                    "timeout": 900.0,
+                    **client_kwargs
+                }
+            if output_model:
+                request_kwargs["response_format"] = output_model
+            if prompt_cache_key:
+                request_kwargs["prompt_cache_key"] = prompt_cache_key
+            
+            response = LLM_client.chat.completions.parse(**request_kwargs)
+            # response = self.client.chat.completions.parse(output_model)
+            content = response.choices[0].message.content
+                # ✅ Validate structured output if a model is provided
+            if output_model is not None:
+                try:
+                    output_model.model_validate_json(content)
+                    base_content = response.choices[0].message.parsed
+                    # base_content = output_model(**content)
+                    return base_content
+                except ValidationError as ve:
+                    # Treat invalid output as retryable
+                    wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1)
+                    print(
+                        f"[Flex Retry] Attempt {attempt+1}/{max_retries} produced invalid structured output. "
+                        f"Retrying in {wait_time:.2f}s... (ValidationError: {ve})"
+                    )
+                    await asyncio.sleep(wait_time)
+                    continue 
+        except (RateLimitError, APIError) as e:
+            wait_time = base_delay * (2 ** attempt) + random.uniform(0, 1)
+            print(
+                f"[Flex Retry] Attempt {attempt+1}/{max_retries} failed "
+                f"with error: {type(e).__name__} - {e}. "
+                f"Retrying in {wait_time:.2f}s..."
+            )
+            await asyncio.sleep(wait_time)
+
+        except Exception as e:
+            # Non-recoverable error: break out immediately
+            raise RuntimeError(
+                f"[Flex Processing] Unrecoverable error for prompt_key={prompt_cache_key}: {e}"
+            )
+
+    raise RuntimeError(
+        f"[Flex Processing] Exhausted {max_retries} retries for prompt_key={prompt_cache_key}"
+    )