hamtaa-texttools 1.1.1__py3-none-any.whl → 1.2.0__py3-none-any.whl

texttools/tools/internals/operator.py

@@ -1,179 +0,0 @@
-from typing import Any, TypeVar, Type, Literal
-import logging
-
-from openai import OpenAI
-from pydantic import BaseModel
-
-from texttools.tools.internals.output_models import ToolOutput
-from texttools.tools.internals.base_operator import BaseOperator
-from texttools.tools.internals.formatters import Formatter
-from texttools.tools.internals.prompt_loader import PromptLoader
-
-# Base Model type for output models
-T = TypeVar("T", bound=BaseModel)
-
-# Configure logger
-logger = logging.getLogger("operator")
-logger.setLevel(logging.INFO)
-
-
-class Operator(BaseOperator):
-    """
-    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.
-    """
-
-    def __init__(self, client: OpenAI, model: str):
-        self.client = client
-        self.model = model
-
-    def _analyze(self, prompt_configs: dict[str, str], temperature: float) -> str:
-        analyze_prompt = prompt_configs["analyze_template"]
-        analyze_message = [self._build_user_message(analyze_prompt)]
-        completion = self.client.chat.completions.create(
-            model=self.model,
-            messages=analyze_message,
-            temperature=temperature,
-        )
-        analysis = completion.choices[0].message.content.strip()
-        return analysis
-
-    def _parse_completion(
-        self,
-        message: list[dict[str, str]],
-        output_model: Type[T],
-        temperature: float,
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-    ) -> tuple[Type[T], Any]:
-        request_kwargs = {
-            "model": self.model,
-            "messages": message,
-            "response_format": output_model,
-            "temperature": temperature,
-        }
-
-        if logprobs:
-            request_kwargs["logprobs"] = True
-            request_kwargs["top_logprobs"] = top_logprobs
-
-        completion = self.client.beta.chat.completions.parse(**request_kwargs)
-        parsed = completion.choices[0].message.parsed
-        return parsed, completion
-
-    def _vllm_completion(
-        self,
-        message: list[dict[str, str]],
-        output_model: Type[T],
-        temperature: float,
-        logprobs: bool = False,
-        top_logprobs: int = 3,
-    ) -> tuple[Type[T], Any]:
-        json_schema = output_model.model_json_schema()
-
-        # Build kwargs dynamically
-        request_kwargs = {
-            "model": self.model,
-            "messages": message,
-            "extra_body": {"guided_json": json_schema},
-            "temperature": temperature,
-        }
-
-        if logprobs:
-            request_kwargs["logprobs"] = True
-            request_kwargs["top_logprobs"] = top_logprobs
-
-        completion = self.client.chat.completions.create(**request_kwargs)
-        response = completion.choices[0].message.content
-
-        # Convert the string response to output model
-        parsed = self._convert_to_output_model(response, output_model)
-        return parsed, completion
-
-    def run(
-        self,
-        # User parameters
-        text: str,
-        with_analysis: bool,
-        output_lang: str | None,
-        user_prompt: str | None,
-        temperature: float,
-        logprobs: bool,
-        top_logprobs: int | None,
-        # Internal parameters
-        prompt_file: str,
-        output_model: Type[T],
-        resp_format: Literal["vllm", "parse"],
-        mode: str | None,
-        **extra_kwargs,
-    ) -> dict[str, Any]:
-        """
-        Execute the LLM pipeline with the given input text.
-        """
-        prompt_loader = PromptLoader()
-        formatter = Formatter()
-
-        try:
-            prompt_configs = prompt_loader.load(
-                prompt_file=prompt_file,
-                text=text.strip(),
-                mode=mode,
-                **extra_kwargs,
-            )
-
-            messages: list[dict[str, str]] = []
-
-            if with_analysis:
-                analysis = self._analyze(prompt_configs, temperature)
-                messages.append(
-                    self._build_user_message(f"Based on this analysis: {analysis}")
-                )
-
-            if output_lang:
-                messages.append(
-                    self._build_user_message(
-                        f"Respond only in the {output_lang} language."
-                    )
-                )
-
-            if user_prompt:
-                messages.append(
-                    self._build_user_message(f"Consider this instruction {user_prompt}")
-                )
-
-            messages.append(self._build_user_message(prompt_configs["main_template"]))
-            messages = formatter.user_merge_format(messages)
-
-            if resp_format == "vllm":
-                parsed, completion = self._vllm_completion(
-                    messages, output_model, temperature, logprobs, top_logprobs
-                )
-            elif resp_format == "parse":
-                parsed, completion = self._parse_completion(
-                    messages, output_model, temperature, logprobs, top_logprobs
-                )
-
-            # Ensure output_model has a `result` field
-            if not hasattr(parsed, "result"):
-                logger.error(
-                    "The provided output_model must define a field named 'result'"
-                )
-
-            output = ToolOutput(result="", analysis="", logprobs=[], errors=[])
-
-            output.result = parsed.result
-
-            if logprobs:
-                output.logprobs = self._extract_logprobs(completion)
-
-            if with_analysis:
-                output.analysis = analysis
-
-            return output
-        except Exception as e:
-            logger.error(f"TheTool failed: {e}")
-            return ToolOutput(result="", analysis="", logprobs=[], errors=[str(e)])

texttools/tools/internals/output_models.py

@@ -1,59 +0,0 @@
-from typing import Literal, Any
-
-from pydantic import BaseModel, Field
-
-
-class ToolOutput(BaseModel):
-    result: str
-    analysis: str
-    logprobs: list[dict[str, Any]]
-    errors: list[str]
-
-
-class StrOutput(BaseModel):
-    result: str = Field(..., description="The output string")
-
-
-class BoolOutput(BaseModel):
-    result: bool = Field(
-        ..., description="Boolean indicating the output state", example=True
-    )
-
-
-class ListStrOutput(BaseModel):
-    result: list[str] = Field(
-        ..., description="The output list of strings", example=["text_1", "text_2"]
-    )
-
-
-class ListDictStrStrOutput(BaseModel):
-    result: list[dict[str, str]] = Field(
-        ...,
-        description="List of dictionaries containing string key-value pairs",
-        example=[{"text": "Mohammad", "type": "PER"}],
-    )
-
-
-class ReasonListStrOutput(BaseModel):
-    reason: str = Field(..., description="Thinking process that led to the output")
-    result: list[str] = Field(..., description="The output list of strings")
-
-
-class CategorizerOutput(BaseModel):
-    reason: str = Field(
-        ..., description="Explanation of why the input belongs to the category"
-    )
-    result: Literal[
-        "باورهای دینی",
-        "اخلاق اسلامی",
-        "احکام و فقه",
-        "تاریخ اسلام و شخصیت ها",
-        "منابع دینی",
-        "دین و جامعه/سیاست",
-        "عرفان و معنویت",
-        "هیچکدام",
-    ] = Field(
-        ...,
-        description="Predicted category label",
-        example="اخلاق اسلامی",
-    )

texttools/tools/internals/prompt_loader.py

@@ -1,57 +0,0 @@
-from functools import lru_cache
-from pathlib import Path
-import yaml
-
-
-class PromptLoader:
-    """
-    Utility for loading and formatting YAML prompt templates.
-
-    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.
-    - Return a dict with:
-        {
-            "main_template": "...",
-            "analyze_template": "..." | None
-        }
-    """
-
-    MAIN_TEMPLATE: str = "main_template"
-    ANALYZE_TEMPLATE: str = "analyze_template"
-
-    # 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]:
-        base_dir = Path(__file__).parent.parent.parent / Path("prompts")
-        prompt_path = base_dir / prompt_file
-        data = yaml.safe_load(prompt_path.read_text(encoding="utf-8"))
-
-        return {
-            self.MAIN_TEMPLATE: data[self.MAIN_TEMPLATE][mode]
-            if mode
-            else data[self.MAIN_TEMPLATE],
-            self.ANALYZE_TEMPLATE: data.get(self.ANALYZE_TEMPLATE)[mode]
-            if mode
-            else data.get(self.ANALYZE_TEMPLATE),
-        }
-
-    def _build_format_args(self, text: str, **extra_kwargs) -> dict[str, str]:
-        # Base formatting args
-        format_args = {"input": text}
-        # Merge extras
-        format_args.update(extra_kwargs)
-        return format_args
-
-    def load(
-        self, prompt_file: str, text: str, mode: str, **extra_kwargs
-    ) -> dict[str, str]:
-        template_configs = self._load_templates(prompt_file, mode)
-        format_args = self._build_format_args(text, **extra_kwargs)
-
-        # Inject variables inside each template
-        for key in template_configs.keys():
-            template_configs[key] = template_configs[key].format(**format_args)
-
-        return template_configs

texttools/tools/the_tool.py

@@ -1,412 +0,0 @@
-from typing import Literal, Any
-
-from openai import OpenAI
-
-from texttools.tools.internals.operator import Operator
-import texttools.tools.internals.output_models as OutputModels
-
-
-class TheTool:
-    """
-    Each method configures the operator with a specific YAML prompt,
-    output schema, and flags, then delegates execution to `operator.run()`.
-
-    Usage:
-        client = OpenAI(...)
-        tool = TheTool(client, model="model-name")
-        result = tool.categorize("text ...", with_analysis=True)
-    """
-
-    def __init__(
-        self,
-        client: OpenAI,
-        model: str,
-    ):
-        self.operator = Operator(client=client, model=model)
-
-    def categorize(
-        self,
-        text: str,
-        with_analysis: bool = False,
-        user_prompt: str | None = None,
-        temperature: float | None = 0.0,
-        logprobs: bool = False,
-        top_logprobs: int | None = None,
-    ) -> dict[str, str]:
-        """
-        Categorize a text into a single Islamic studies domain category.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (str): The assigned Islamic studies category
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        return self.operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            # Internal parameters
-            prompt_file="categorizer.yaml",
-            output_model=OutputModels.CategorizerOutput,
-            resp_format="parse",
-            mode=None,
-            output_lang=None,
-        )
-
-    def extract_keywords(
-        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,
-    ) -> dict[str, list[str]]:
-        """
-        Extract salient keywords from text.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (list[str]): List of extracted keywords
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        return 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,
-            # Internal parameters
-            prompt_file="extract_keywords.yaml",
-            output_model=OutputModels.ListStrOutput,
-            resp_format="parse",
-            mode=None,
-        )
-
-    def extract_entities(
-        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,
-    ) -> dict[str, list[dict[str, str]]]:
-        """
-        Perform Named Entity Recognition (NER) over the input text.
-
-        Returns:
-            ToolOutput: Object containing:
-                - 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
-        """
-        return 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,
-            # Internal parameters
-            prompt_file="extract_entities.yaml",
-            output_model=OutputModels.ListDictStrStrOutput,
-            resp_format="parse",
-            mode=None,
-        )
-
-    def is_question(
-        self,
-        text: str,
-        with_analysis: bool = False,
-        user_prompt: str | None = None,
-        temperature: float | None = 0.0,
-        logprobs: bool = False,
-        top_logprobs: int | None = None,
-    ) -> dict[str, bool]:
-        """
-        Detect if the input is phrased as a question.
-
-        Returns:
-            ToolOutput: Object containing:
-                - 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
-        """
-        return self.operator.run(
-            # User parameters
-            text=text,
-            with_analysis=with_analysis,
-            user_prompt=user_prompt,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            # Internal parameters
-            prompt_file="is_question.yaml",
-            output_model=OutputModels.BoolOutput,
-            resp_format="parse",
-            mode=None,
-            output_lang=None,
-        )
-
-    def text_to_question(
-        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,
-    ) -> dict[str, str]:
-        """
-        Generate a single question from the given text.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (str): The generated question
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        return 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,
-            # Internal parameters
-            prompt_file="text_to_question.yaml",
-            output_model=OutputModels.StrOutput,
-            resp_format="parse",
-            mode=None,
-        )
-
-    def merge_questions(
-        self,
-        text: list[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,
-        mode: Literal["default", "reason"] = "default",
-    ) -> dict[str, str]:
-        """
-        Merge multiple questions into a single unified question.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (str): The merged question
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        text = ", ".join(text)
-        return 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,
-            # Internal parameters
-            prompt_file="merge_questions.yaml",
-            output_model=OutputModels.StrOutput,
-            resp_format="parse",
-            mode=mode,
-        )
-
-    def rewrite(
-        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,
-        mode: Literal["positive", "negative", "hard_negative"] = "positive",
-    ) -> dict[str, str]:
-        """
-        Rewrite a text with different modes.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (str): The rewritten text
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        return 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,
-            # Internal parameters
-            prompt_file="rewrite.yaml",
-            output_model=OutputModels.StrOutput,
-            resp_format="parse",
-            mode=mode,
-        )
-
-    def subject_to_question(
-        self,
-        text: str,
-        number_of_questions: int,
-        with_analysis: bool = False,
-        output_lang: str | None = None,
-        user_prompt: str | None = None,
-        temperature: float | None = 0.0,
-        logprobs: bool = False,
-        top_logprobs: int | None = None,
-    ) -> dict[str, list[str]]:
-        """
-        Generate a list of questions about a subject.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (list[str]): List of generated questions
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        return 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,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            # Internal parameters
-            prompt_file="subject_to_question.yaml",
-            output_model=OutputModels.ReasonListStrOutput,
-            resp_format="parse",
-            mode=None,
-        )
-
-    def summarize(
-        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,
-    ) -> dict[str, str]:
-        """
-        Summarize the given subject text.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (str): The summary text
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        return 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,
-            # Internal parameters
-            prompt_file="summarize.yaml",
-            output_model=OutputModels.StrOutput,
-            resp_format="parse",
-            mode=None,
-        )
-
-    def translate(
-        self,
-        text: str,
-        target_language: str,
-        with_analysis: bool = False,
-        user_prompt: str | None = None,
-        temperature: float | None = 0.0,
-        logprobs: bool = False,
-        top_logprobs: int | None = None,
-    ) -> dict[str, str]:
-        """
-        Translate text between languages.
-
-        Returns:
-            ToolOutput: Object containing:
-                - result (str): The translated text
-                - logprobs (list | None): Probability data if logprobs enabled
-                - analysis (str | None): Detailed reasoning if with_analysis enabled
-        """
-        return 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,
-            # Internal parameters
-            prompt_file="translate.yaml",
-            output_model=OutputModels.StrOutput,
-            resp_format="parse",
-            mode=None,
-            output_lang=None,
-        )
-
-    def run_custom(
-        self,
-        prompt: str,
-        output_model: Any,
-        output_lang: str | None = None,
-        temperature: float | None = None,
-        logprobs: bool | None = None,
-        top_logprobs: int | None = None,
-    ) -> dict[str, Any]:
-        """
-        Custom tool that can do almost anything!
-
-        Returns:
-            ToolOutput: Object with fields:
-                - result (str): The output result
-        """
-        return self.operator.run(
-            # User paramaeters
-            text=prompt,
-            output_model=output_model,
-            output_model_str=output_model.model_json_schema(),
-            output_lang=output_lang,
-            temperature=temperature,
-            logprobs=logprobs,
-            top_logprobs=top_logprobs,
-            # Internal parameters
-            prompt_file="run_custom.yaml",
-            resp_format="parse",
-            user_prompt=None,
-            with_analysis=False,
-            mode=None,
-        )