hamtaa-texttools 1.3.2__py3-none-any.whl → 2.1.0__py3-none-any.whl

hamtaa_texttools-1.3.2.dist-info/RECORD

@@ -1,31 +0,0 @@
-hamtaa_texttools-1.3.2.dist-info/licenses/LICENSE,sha256=Hb2YOBKy2MJQLnyLrX37B4ZVuac8eaIcE71SvVIMOLg,1082
-texttools/__init__.py,sha256=RK1GAU6pq2lGwFtHdrCX5JkPRHmOLGcmGH67hd_7VAQ,175
-texttools/models.py,sha256=5eT2cSrFq8Xa38kANznV7gbi7lwB2PoDxciLKTpsd6c,2516
-texttools/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/core/engine.py,sha256=AjifrcJl6PeRu1W6nu9zcxySn-1439Ef2La4d7GpNKY,9481
-texttools/core/exceptions.py,sha256=6SDjUL1rmd3ngzD3ytF4LyTRj3bQMSFR9ECrLoqXXHw,395
-texttools/core/internal_models.py,sha256=J1qGEO8V0OoX6_-1yxbSmZSR79tJF0ExAIG1QuvH0L0,1734
-texttools/core/operators/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/core/operators/async_operator.py,sha256=-72YQEGFkbk2uYW6PHkLT4wGxhj2p6Uqy3sJtVa9-rk,6386
-texttools/core/operators/sync_operator.py,sha256=mfXtEOlIAhHo4SHaHRKjGb0Z1T894clv-toUzUcbfpo,6291
-texttools/prompts/categorize.yaml,sha256=42Rp3SgVHaDLKrJ27_uK788LiQud0pOXJthz4r0a40Y,1214
-texttools/prompts/check_fact.yaml,sha256=zWFQDRhEE1ij9wSeeenS9YSTM-bY5zzUaG390zUgmcs,714
-texttools/prompts/extract_entities.yaml,sha256=_zYKHNJDIzVDI_-TnwFCKyMs-XLM5igvmWhvSTc3INQ,637
-texttools/prompts/extract_keywords.yaml,sha256=1o4u3uwzapNtB1BUpNIRL5qtrwjW0Yhvyq0TZJiafdg,3272
-texttools/prompts/is_question.yaml,sha256=jnPARd2ZiulLzHW_r4WAsz3sOryfz6Gy5-yYXp-2hd0,496
-texttools/prompts/merge_questions.yaml,sha256=l9Q2OEjPp3SDkxbq3zZCj2ZmXacWSnmYMpUr3l6r5yE,1816
-texttools/prompts/propositionize.yaml,sha256=nbGAfbm1-2Hoc0JLtqZi-S7VHQfnMmuTKI7dZeBxQW0,1403
-texttools/prompts/rewrite.yaml,sha256=klEm8MqXK-Bo8RsS5R9KLMT0zlD-BKo_G6tz9lpAcEY,5420
-texttools/prompts/run_custom.yaml,sha256=IETY9H0wPGWIIzcnupfbwwKQblwZrbYAxB754W9MhgU,125
-texttools/prompts/subject_to_question.yaml,sha256=AK16pZW9HUppIF8JBSEenbUNOU3aqeVV781_WUXnLqk,1160
-texttools/prompts/summarize.yaml,sha256=rPh060Bx_yI1W2JNg-nr83LUk9itatYLKM8ciH2pOvg,486
-texttools/prompts/text_to_question.yaml,sha256=pUwPgK9l5f8S4E5fCht9JY7PFVK2aY1InPfASr7R5o4,1017
-texttools/prompts/translate.yaml,sha256=Dd5bs3O8SI-FlVSwHMYGeEjMmdOWeRlcfBHkhixCx7c,665
-texttools/tools/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/tools/async_tools.py,sha256=2suwx8N0aRnowaSOpV6C57AqPlmQe5Z0Yx4E5QIMkmU,46939
-texttools/tools/sync_tools.py,sha256=mEuL-nlbxVW30dPE3hGkAUnYXbul-3gN2Le4CMVFCgU,42528
-hamtaa_texttools-1.3.2.dist-info/METADATA,sha256=LjhXLwovneW5Ii1DvAYhFT4JR64ar23UyptCvCO6Hpc,7448
-hamtaa_texttools-1.3.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-1.3.2.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-1.3.2.dist-info/RECORD,,

texttools/core/engine.py

@@ -1,262 +0,0 @@
-import asyncio
-import math
-import random
-import re
-from functools import lru_cache
-from pathlib import Path
-from typing import Any
-
-import yaml
-
-from .exceptions import PromptError
-
-
-class PromptLoader:
-    """
-    Utility for loading and formatting YAML prompt templates.
-    """
-
-    MAIN_TEMPLATE = "main_template"
-    ANALYZE_TEMPLATE = "analyze_template"
-
-    @lru_cache(maxsize=32)
-    def _load_templates(self, prompt_file: str, mode: str | None) -> dict[str, str]:
-        try:
-            base_dir = Path(__file__).parent.parent / Path("prompts")
-            prompt_path = base_dir / prompt_file
-
-            if not prompt_path.exists():
-                raise PromptError(f"Prompt file not found: {prompt_file}")
-
-            data = yaml.safe_load(prompt_path.read_text(encoding="utf-8"))
-
-            if self.MAIN_TEMPLATE not in data:
-                raise PromptError(f"Missing 'main_template' in {prompt_file}")
-
-            if self.ANALYZE_TEMPLATE not in data:
-                raise PromptError(f"Missing 'analyze_template' in {prompt_file}")
-
-            if mode and mode not in data.get(self.MAIN_TEMPLATE, {}):
-                raise PromptError(f"Mode '{mode}' not found in {prompt_file}")
-
-            main_template = (
-                data[self.MAIN_TEMPLATE][mode]
-                if mode and isinstance(data[self.MAIN_TEMPLATE], dict)
-                else data[self.MAIN_TEMPLATE]
-            )
-
-            analyze_template = (
-                data[self.ANALYZE_TEMPLATE][mode]
-                if mode and isinstance(data[self.ANALYZE_TEMPLATE], dict)
-                else data[self.ANALYZE_TEMPLATE]
-            )
-
-            if not main_template or not main_template.strip():
-                raise PromptError(
-                    f"Empty main_template in {prompt_file}"
-                    + (f" for mode '{mode}'" if mode else "")
-                )
-
-            return {
-                self.MAIN_TEMPLATE: main_template,
-                self.ANALYZE_TEMPLATE: analyze_template,
-            }
-
-        except yaml.YAMLError as e:
-            raise PromptError(f"Invalid YAML in {prompt_file}: {e}")
-        except Exception as e:
-            raise PromptError(f"Failed to load prompt {prompt_file}: {e}")
-
-    def load(
-        self, prompt_file: str, text: str, mode: str, **extra_kwargs
-    ) -> dict[str, str]:
-        try:
-            format_args = {"text": text}
-            format_args.update(extra_kwargs)
-
-            template_configs = self._load_templates(prompt_file, mode)
-            for key, value in template_configs.items():
-                template_configs[key] = value.format(**format_args)
-
-            return template_configs
-
-        except KeyError as e:
-            raise PromptError(f"Missing template variable: {e}")
-        except Exception as e:
-            raise PromptError(f"Failed to format prompt: {e}")
-
-
-class OperatorUtils:
-    @staticmethod
-    def build_main_prompt(
-        main_template: str,
-        analysis: str | None,
-        output_lang: str | None,
-        user_prompt: str | None,
-    ) -> str:
-        parts = []
-
-        if analysis:
-            parts.append(f"Based on this analysis: {analysis}")
-        if output_lang:
-            parts.append(f"Respond only in the {output_lang} language.")
-        if user_prompt:
-            parts.append(f"Consider this instruction: {user_prompt}")
-
-        parts.append(main_template)
-        return "\n".join(parts)
-
-    @staticmethod
-    def build_message(prompt: str) -> list[dict[str, str]]:
-        return [{"role": "user", "content": prompt}]
-
-    @staticmethod
-    def extract_logprobs(completion: Any) -> list[dict]:
-        """
-        Extracts and filters logprobs from completion.
-        Skips punctuation and structural tokens.
-        """
-        logprobs_data = []
-
-        ignore_pattern = re.compile(r'^(result|[\s\[\]\{\}",:]+)$')
-
-        for choice in completion.choices:
-            if not getattr(choice, "logprobs", None):
-                raise ValueError("Your model does not support logprobs")
-
-            for logprob_item in choice.logprobs.content:
-                if ignore_pattern.match(logprob_item.token):
-                    continue
-                token_entry = {
-                    "token": logprob_item.token,
-                    "prob": round(math.exp(logprob_item.logprob), 8),
-                    "top_alternatives": [],
-                }
-                for alt in logprob_item.top_logprobs:
-                    if ignore_pattern.match(alt.token):
-                        continue
-                    token_entry["top_alternatives"].append(
-                        {
-                            "token": alt.token,
-                            "prob": round(math.exp(alt.logprob), 8),
-                        }
-                    )
-                logprobs_data.append(token_entry)
-
-        return logprobs_data
-
-    @staticmethod
-    def get_retry_temp(base_temp: float) -> float:
-        new_temp = base_temp + random.choice([-1, 1]) * random.uniform(0.1, 0.9)
-        return max(0.0, min(new_temp, 1.5))
-
-
-def text_to_chunks(text: str, size: int, overlap: int) -> list[str]:
-    """
-    Utility for chunking large texts. Used for translation tool
-    """
-    separators = ["\n\n", "\n", " ", ""]
-    is_separator_regex = False
-    keep_separator = True
-    length_function = len
-    strip_whitespace = True
-    chunk_size = size
-    chunk_overlap = overlap
-
-    def _split_text_with_regex(
-        text: str, separator: str, keep_separator: bool
-    ) -> list[str]:
-        if not separator:
-            return [text]
-        if not keep_separator:
-            return re.split(separator, text)
-        _splits = re.split(f"({separator})", text)
-        splits = [_splits[i] + _splits[i + 1] for i in range(1, len(_splits), 2)]
-        if len(_splits) % 2 == 0:
-            splits += [_splits[-1]]
-        return [_splits[0]] + splits if _splits[0] else splits
-
-    def _join_docs(docs: list[str], separator: str) -> str | None:
-        text = separator.join(docs)
-        if strip_whitespace:
-            text = text.strip()
-        return text if text else None
-
-    def _merge_splits(splits: list[str], separator: str) -> list[str]:
-        separator_len = length_function(separator)
-        docs = []
-        current_doc = []
-        total = 0
-        for d in splits:
-            len_ = length_function(d)
-            if total + len_ + (separator_len if current_doc else 0) > chunk_size:
-                if total > chunk_size:
-                    pass
-                if current_doc:
-                    doc = _join_docs(current_doc, separator)
-                    if doc is not None:
-                        docs.append(doc)
-                    while total > chunk_overlap or (
-                        total + len_ + (separator_len if current_doc else 0)
-                        > chunk_size
-                        and total > 0
-                    ):
-                        total -= length_function(current_doc[0]) + (
-                            separator_len if len(current_doc) > 1 else 0
-                        )
-                        current_doc = current_doc[1:]
-            current_doc.append(d)
-            total += len_ + (separator_len if len(current_doc) > 1 else 0)
-        doc = _join_docs(current_doc, separator)
-        if doc is not None:
-            docs.append(doc)
-        return docs
-
-    def _split_text(text: str, separators: list[str]) -> list[str]:
-        final_chunks = []
-        separator = separators[-1]
-        new_separators = []
-        for i, _s in enumerate(separators):
-            separator_ = _s if is_separator_regex else re.escape(_s)
-            if not _s:
-                separator = _s
-                break
-            if re.search(separator_, text):
-                separator = _s
-                new_separators = separators[i + 1 :]
-                break
-        separator_ = separator if is_separator_regex else re.escape(separator)
-        splits = _split_text_with_regex(text, separator_, keep_separator)
-        _separator = "" if keep_separator else separator
-        good_splits = []
-        for s in splits:
-            if length_function(s) < chunk_size:
-                good_splits.append(s)
-            else:
-                if good_splits:
-                    merged_text = _merge_splits(good_splits, _separator)
-                    final_chunks.extend(merged_text)
-                    good_splits = []
-                if not new_separators:
-                    final_chunks.append(s)
-                else:
-                    other_info = _split_text(s, new_separators)
-                    final_chunks.extend(other_info)
-        if good_splits:
-            merged_text = _merge_splits(good_splits, _separator)
-            final_chunks.extend(merged_text)
-        return final_chunks
-
-    return _split_text(text, separators)
-
-
-async def run_with_timeout(coro, timeout: float | None):
-    """
-    Utility for timeout logic defined in AsyncTheTool
-    """
-    if timeout is None:
-        return await coro
-    try:
-        return await asyncio.wait_for(coro, timeout=timeout)
-    except asyncio.TimeoutError:
-        raise TimeoutError(f"Operation exceeded timeout of {timeout} seconds")

texttools/prompts/subject_to_question.yaml

@@ -1,26 +0,0 @@
-main_template: |
-  You are a question from subject generator.
-  Given the following subject, generate {number_of_questions} appropriate questions that this subject would directly respond to.
-  The generated subject should be independently meaningful,
-  and it must not mention any verbs like, this, that, he or she and etc. in the question.
-  
-  There is a `reason` key, fill that up with a summerized version of your thoughts.
-  The `reason` must be less than 20 words.
-  Don't forget to fill the reason.
-
-  Respond only in JSON format:
-  {{"result": ["question1", "question2", ...], "reason": "string"}}
-
-  Here is the subject:
-  {text}
-
-analyze_template: |
-  Our goal is to generate questions from the given subject.
-  The questions must be meaningfull, some of them should be specific and some should be general.
-  But first, in this step we want to analyze the subject that I asked to generate questions for it.
-  We need a summerized analysis of the subject.
-  What is the subject about?
-  What point of views can we see and generate questoins from it? (Questions that real users might have.)
-  
-  Here is the subject:
-  {text}

texttools/prompts/text_to_question.yaml

@@ -1,26 +0,0 @@
-main_template: |
-  You are a question generator.
-  Given the following answer, generate {number_of_questions} appropriate questions that this answer would directly respond to.
-  The generated answer should be independently meaningful,
-  and not mentioning any verbs like, this, that, he or she on the question.
-  
-  There is a `reason` key, fill that up with a summerized version of your thoughts.
-  The `reason` must be less than 20 words.
-  Don't forget to fill the reason.
-
-  Respond only in JSON format:
-  {{"result": ["question1", "question2", ...], "reason": "string"}}
-  
-  Here is the answer:
-  {text}
-  
-analyze_template: |
-  Analyze the following answer to identify its key facts,
-  main subject, and what kind of information it provides.
-  Provide a brief, summarized understanding of the answer's content that will 
-  help in formulating relevant and direct questions.
-  Just mention the keypoints that was provided in the answer
-  
-  Here is the answer:
-  {text}
-