hamtaa-texttools 0.1.44__py3-none-any.whl → 1.0.1__py3-none-any.whl

texttools/tools/prompt_loader.py

@@ -0,0 +1,84 @@
+from typing import Optional
+from pathlib import Path
+import yaml
+
+
+class PromptLoader:
+    """
+    Utility for loading and formatting YAML prompt templates.
+
+    Each YAML file under `prompts/` must define at least a `main_template`,
+    and optionally an `analyze_template`. These can either be a single string
+    or a dictionary keyed by mode names (if `use_modes=True`).
+
+    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"
+
+    def __init__(self, prompts_dir: Optional[str] = None):
+        self.PROMPTS_DIR = prompts_dir or "prompts"
+
+    def _get_prompt_path(self, prompt_file: str) -> Path:
+        return Path(__file__).parent.parent / self.PROMPTS_DIR / prompt_file
+
+    def _load_templates(
+        self, prompt_file: str, use_modes: bool, mode: str
+    ) -> dict[str, str]:
+        prompt_path = self._get_prompt_path(prompt_file)
+
+        if not prompt_path.exists():
+            raise FileNotFoundError(f"Prompt file not found: {prompt_path}")
+
+        try:
+            # Load the data
+            data = yaml.safe_load(prompt_path.read_text(encoding="utf-8"))
+        except yaml.YAMLError as e:
+            raise ValueError(f"Invalid YAML in {prompt_path}: {e}")
+
+        if self.MAIN_TEMPLATE not in data:
+            raise ValueError(
+                f"Missing required '{self.MAIN_TEMPLATE}' in {prompt_file}"
+            )
+
+        return {
+            self.MAIN_TEMPLATE: data[self.MAIN_TEMPLATE][mode]
+            if use_modes
+            else data[self.MAIN_TEMPLATE],
+            self.ANALYZE_TEMPLATE: data.get(self.ANALYZE_TEMPLATE)[mode]
+            if use_modes
+            else data.get(self.ANALYZE_TEMPLATE),
+        }
+
+    def _build_format_args(self, input_text: str, **extra_kwargs) -> dict[str, str]:
+        # Base formatting args
+        format_args = {"input": input_text}
+        # Merge extras
+        format_args.update(extra_kwargs)
+        return format_args
+
+    def load_prompts(
+        self,
+        prompt_file: str,
+        use_modes: bool,
+        mode: str,
+        input_text: str,
+        **extra_kwargs,
+    ) -> dict[str, str]:
+        template_configs = self._load_templates(prompt_file, use_modes, mode)
+        format_args = self._build_format_args(input_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

@@ -0,0 +1,291 @@
+from typing import Literal, Any
+
+from openai import OpenAI
+
+from texttools.tools.operator import Operator
+import texttools.tools.output_models as OutputModels
+
+
+class TheTool:
+    """
+    High-level interface exposing specialized text tools for.
+
+    Each method configures the operator with a specific YAML prompt,
+    output schema, and flags, then delegates execution to `operator.run()`.
+
+    Supported capabilities:
+    - categorize: assign a text to one of several Islamic categories.
+    - extract_keywords: produce a keyword list from text.
+    - extract_entities: simple NER (name/type pairs).
+    - detect_question: binary check whether input is a question.
+    - generate_question_from_text: produce a new question from a text.
+    - merge_questions: combine multiple questions (default/reason modes).
+    - rewrite_question: rephrase questions (same meaning/different wording, or vice versa).
+    - generate_questions_from_subject: generate multiple questions given a subject.
+    - summarize: produce a concise summary of a subject.
+    - translate: translate text between languages.
+
+    Usage pattern:
+        client = OpenAI(...)
+        tool = TheTool(client, model="gemma-3")
+        result = tool.categorize("متن ورودی ...", with_analysis=True)
+    """
+
+    def __init__(
+        self,
+        client: OpenAI,
+        *,
+        model: str,
+        temperature: float = 0.0,
+        **client_kwargs: Any,
+    ):
+        self.operator = Operator(
+            client=client,
+            model=model,
+            temperature=temperature,
+            **client_kwargs,
+        )
+
+    def categorize(self, text: str, with_analysis: bool = False) -> dict[str, str]:
+        """
+        Categorize a text into a single Islamic studies domain category.
+
+        Args:
+            text: Input string to categorize.
+            with_analysis: If True, first runs an LLM "analysis" step and
+                           conditions the main prompt on that analysis.
+
+        Returns:
+            {"result": <category string>}
+            Example: {"result": "باورهای دینی"}
+        """
+        self.operator.PROMPT_FILE = "categorizer.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.CategorizerOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(text)
+        return results
+
+    def extract_keywords(
+        self, text: str, with_analysis: bool = False
+    ) -> dict[str, list[str]]:
+        """
+        Extract salient keywords from text.
+
+        Args:
+            text: Input string to analyze.
+            with_analysis: Whether to run an extra LLM reasoning step.
+
+        Returns:
+            {"result": [<keyword1>, <keyword2>, ...]}
+        """
+        self.operator.PROMPT_FILE = "keyword_extractor.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.ListStrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(text)
+        return results
+
+    def extract_entities(
+        self, text: str, with_analysis: bool = False
+    ) -> dict[str, list[dict[str, str]]]:
+        """
+        Perform Named Entity Recognition (NER) over the input text.
+
+        Args:
+            text: Input string.
+            with_analysis: Whether to run an extra LLM reasoning step.
+
+        Returns:
+            {"result": [{"text": <entity>, "type": <entity_type>}, ...]}
+        """
+        self.operator.PROMPT_FILE = "ner_extractor.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.ListDictStrStrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(text)
+        return results
+
+    def detect_question(
+        self, question: str, with_analysis: bool = False
+    ) -> dict[str, str]:
+        """
+        Detect if the input is phrased as a question.
+
+        Args:
+            question: Input string to evaluate.
+            with_analysis: Whether to include an analysis step.
+
+        Returns:
+            {"result": "true"} or {"result": "false"}
+        """
+        self.operator.PROMPT_FILE = "question_detector.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.StrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(question)
+        return results
+
+    def generate_question_from_text(
+        self, text: str, with_analysis: bool = False
+    ) -> dict[str, str]:
+        """
+        Generate a single question from the given text.
+
+        Args:
+            text: Source text to derive a question from.
+            with_analysis: Whether to use analysis before generation.
+
+        Returns:
+            {"result": <generated_question>}
+        """
+        self.operator.PROMPT_FILE = "question_generator.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.StrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(text)
+        return results
+
+    def merge_questions(
+        self,
+        questions: list[str],
+        mode: Literal["default_mode", "reason_mode"] = "default_mode",
+        with_analysis: bool = False,
+    ) -> dict[str, str]:
+        """
+        Merge multiple questions into a single unified question.
+
+        Args:
+            questions: List of question strings.
+            mode: Merge strategy:
+                - "default_mode": simple merging.
+                - "reason_mode": merging with reasoning explanation.
+            with_analysis: Whether to use an analysis step.
+
+        Returns:
+            {"result": <merged_question>}
+        """
+        question_str = ", ".join(questions)
+
+        self.operator.PROMPT_FILE = "question_merger.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.StrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = True
+        self.operator.MODE = mode
+
+        results = self.operator.run(question_str)
+        return results
+
+    def rewrite_question(
+        self,
+        question: str,
+        mode: Literal[
+            "same_meaning_different_wording_mode",
+            "different_meaning_similar_wording_mode",
+        ] = "same_meaning_different_wording_mode",
+        with_analysis: bool = False,
+    ) -> dict[str, str]:
+        """
+        Rewrite a question with different wording or meaning.
+
+        Args:
+            question: Input question to rewrite.
+            mode: Rewrite strategy:
+                - "same_meaning_different_wording_mode": keep meaning, change words.
+                - "different_meaning_similar_wording_mode": alter meaning, preserve wording style.
+            with_analysis: Whether to include an analysis step.
+
+        Returns:
+            {"result": <rewritten_question>}
+        """
+        self.operator.PROMPT_FILE = "question_rewriter.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.StrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = True
+        self.operator.MODE = mode
+
+        results = self.operator.run(question)
+        return results
+
+    def generate_questions_from_subject(
+        self,
+        subject: str,
+        number_of_questions: int,
+        language: str = "English",
+        with_analysis: bool = False,
+    ) -> dict[str, list[str]]:
+        """
+        Generate a list of questions about a subject.
+
+        Args:
+            subject: Topic of interest.
+            number_of_questions: Number of questions to produce.
+            language: Target language for generated questions.
+            with_analysis: Whether to include an analysis step.
+
+        Returns:
+            {"result": [<question1>, <question2>, ...]}
+        """
+        self.operator.PROMPT_FILE = "subject_question_generator.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.ReasonListStrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(
+            subject,
+            number_of_questions=number_of_questions,
+            language=language,
+        )
+        return results
+
+    def summarize(self, subject: str, with_analysis: bool = False) -> dict[str, str]:
+        """
+        Summarize the given subject text.
+
+        Args:
+            subject: Input text to summarize.
+            with_analysis: Whether to include an analysis step.
+
+        Returns:
+            {"result": <summary>}
+        """
+        self.operator.PROMPT_FILE = "summarizer.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.StrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(subject)
+        return results
+
+    def translate(
+        self,
+        text: str,
+        target_language: str,
+        with_analysis: bool = False,
+    ) -> dict[str, str]:
+        """
+        Translate text between languages.
+
+        Args:
+            text: Input string to translate.
+            target_language: Language code or name to translate into.
+            with_analysis: Whether to include an analysis step.
+
+        Returns:
+            {"result": <translated_text>}
+        """
+        self.operator.PROMPT_FILE = "translator.yaml"
+        self.operator.OUTPUT_MODEL = OutputModels.StrOutput
+        self.operator.WITH_ANALYSIS = with_analysis
+        self.operator.USE_MODES = False
+
+        results = self.operator.run(
+            text,
+            target_language=target_language,
+        )
+        return results

texttools/utils/__init__.py

@@ -0,0 +1,4 @@
+from .batch_manager.batch_manager import SimpleBatchManager
+from .batch_manager.batch_runner import BatchJobRunner
+
+__all__ = ["SimpleBatchManager", "BatchJobRunner"]

texttools/{batch_manager → utils/batch_manager}/__init__.py

@@ -1,2 +1,4 @@
 from .batch_manager import SimpleBatchManager
 from .batch_runner import BatchJobRunner
+
+__all__ = ["SimpleBatchManager", "BatchJobRunner"]

texttools/{batch_manager → utils/batch_manager}/batch_manager.py

@@ -6,10 +6,17 @@ from typing import Any, Optional, Type
 from pydantic import BaseModel
 from openai import OpenAI
 from openai.lib._pydantic import to_strict_json_schema
-# from openai.lib._parsing._completions import type_to_response_format_param
 
 
 class SimpleBatchManager:
+    """
+    Manages batch processing jobs for OpenAI's chat completions with structured outputs.
+
+    Handles the full lifecycle of a batch job: creating tasks from input texts,
+    starting the job, monitoring status, and fetching results. Results are automatically
+    parsed into the specified Pydantic output model. Job state is persisted to disk.
+    """
+
     def __init__(
         self,
         client: OpenAI,
@@ -70,18 +77,12 @@ class SimpleBatchManager:
         Builds a single task dictionary for the batch job, including the prompt, model, and response format configuration.
         """
         response_format_config: dict[str, Any]
+
         if self.custom_json_schema_obj_str:
-            # try:
-            # parsed_custom_schema = json.loads(self.custom_json_schema_obj_str)
             response_format_config = {
                 "type": "json_schema",
                 "json_schema": self.custom_json_schema_obj_str,
             }
-        # except json.JSONDecodeError as e:
-        #     raise ValueError(
-        #         "Failed to parse custom_json_schema_obj_str. "
-        #         "Please ensure it's a valid JSON string."
-        #     ) from e
         else:
             raw_schema = to_strict_json_schema(self.output_model)
             response_format_config = {
@@ -167,7 +168,7 @@ class SimpleBatchManager:
         Returns a list of dictionaries with 'id' and 'output' keys.
         """
         modified_result = []
-        # errors = []
+
         for key, d in result.items():
             if "desired_output" in d:
                 new_dict = {"id": key, "output": d["desired_output"]}
@@ -176,7 +177,6 @@ class SimpleBatchManager:
                 new_dict = {"id": key, "output": d["error"]}
                 modified_result.append(new_dict)
         return modified_result
-        # return modified_result , errors
 
     def fetch_results(
         self, job_name: str, remove_cache: bool = True
@@ -236,6 +236,5 @@ class SimpleBatchManager:
             handler.handle(results)
         if remove_cache:
             self._clear_state(job_name)
-        # results = {"results": results, "log": log}
-        # return results
+
         return results, log

texttools/{batch_manager → utils/batch_manager}/batch_runner.py

@@ -5,18 +5,17 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Callable
 
-# from dotenv import load_dotenv
 from openai import OpenAI
 from pydantic import BaseModel
 
-from texttools.batch_manager import SimpleBatchManager
+from texttools.utils.batch_manager import SimpleBatchManager
 
 
-class OutputModel(BaseModel):
-    desired_output: str
+class Output(BaseModel):
+    output: str
 
 
-def exporting_data(data):
+def export_data(data):
     """
     Produces a structure of the following form from an initial data structure:
     [
@@ -26,7 +25,7 @@ def exporting_data(data):
     return data
 
 
-def importing_data(data):
+def import_data(data):
     """
     Takes the output and adds and aggregates it to the original structure.
     """
@@ -49,17 +48,21 @@ class BatchConfig:
     CHARS_PER_TOKEN: float = 2.7
     PROMPT_TOKEN_MULTIPLIER: int = 1000
     BASE_OUTPUT_DIR: str = "Data/batch_entity_result"
-    import_function: Callable = importing_data
-    export_function: Callable = exporting_data
+    import_function: Callable = import_data
+    export_function: Callable = export_data
 
 
 class BatchJobRunner:
     """
-    Handles running batch jobs using a batch manager and configuration.
+    Orchestrates the execution of batched LLM processing jobs.
+
+    Handles data loading, partitioning, job execution via SimpleBatchManager,
+    and result saving. Manages the complete workflow from input data to processed outputs,
+    including retries and progress tracking across multiple batch parts.
     """
 
     def __init__(
-        self, config: BatchConfig = BatchConfig(), output_model: type = OutputModel
+        self, config: BatchConfig = BatchConfig(), output_model: type = Output
     ):
         self.config = config
         self.system_prompt = config.system_prompt
@@ -75,7 +78,6 @@ class BatchJobRunner:
         Path(self.config.BASE_OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
 
     def _init_manager(self) -> SimpleBatchManager:
-        # load_dotenv()
         api_key = os.getenv("OPENAI_API_KEY")
         client = OpenAI(api_key=api_key)
         return SimpleBatchManager(
@@ -90,7 +92,7 @@ class BatchJobRunner:
             data = json.load(f)
         data = self.config.export_function(data)
 
-        # Validation: ensure data is a list of dicts with 'id' and 'content' as strings
+        # Ensure data is a list of dicts with 'id' and 'content' as strings
         if not isinstance(data, list):
             raise ValueError(
                 'Exported data must be a list in this form:  [ {"id": str, "content": str},...]'
@@ -159,10 +161,13 @@ class BatchJobRunner:
                 elif status == "failed":
                     print("Job failed. Clearing state, waiting, and retrying...")
                     self.manager._clear_state(part_job_name)
-                    time.sleep(10)  # Wait before retrying
-                    break  # Break inner loop to restart the job
+                    # Wait before retrying
+                    time.sleep(10)
+                    # Break inner loop to restart the job
+                    break
                 else:
-                    time.sleep(5)  # Wait before checking again
+                    # Wait before checking again
+                    time.sleep(5)
 
     def _save_results(
         self, output_data: list[dict[str, Any]], log: list[Any], part_idx: int

hamtaa_texttools-0.1.44.dist-info/METADATA

@@ -1,60 +0,0 @@
-Metadata-Version: 2.4
-Name: hamtaa-texttools
-Version: 0.1.44
-Summary: A set of high-level NLP tools
-Author: Tohidi, Montazer, Givechi, Mousavinezhad
-Requires-Python: >=3.8
-Description-Content-Type: text/markdown
-Requires-Dist: openai>=1.97.0
-Requires-Dist: numpy>=1.26.4
-
-# Text Tools
-
-<p align="center">
-  <img src="https://img.shields.io/badge/TextTools-Python%20Text%20Processing-black?style=for-the-badge&logo=python&logoColor=white">
-</p>
-
-
-<p align="center">
-  <img src="docs/logo.png" alt="Preview" width="300" height="300">
-</p>
-
-
-## How to Install
-
-Install the package using:
-
-```bash
-pip install -U hamta-texttools
-```
-
-
----
-
-## What This Library Is *Not*
-
-This is **not** a collection of low-level utilities.
-
-To clarify: this library **does not** include things like:
-- An standard `regex`
-- Word normalization utilities
-
----
-
-## What This Library *Provides*
-
-This is a set of **high-level natural language processing (NLP)** tools.
-
-Some of the features include:
-- `question_detector`: Detecting if an incoming text is a question or not
-- `categorizer`: No finetuning need, categorizer
-- ... (Tell me what you want!)
-
----
-
-## When to Use This Library
-
-Use `texttools` when:
-- You need to **process large volumes of data using OpenAI’s GPT models** via the BATCH API.
-- You want to treat an **LLM as a function** in Python that outputs structured JSON or Pydantic models.
-- You need to **categorize large datasets** using vector embeddings, efficiently and at scale.

hamtaa_texttools-0.1.44.dist-info/RECORD

@@ -1,60 +0,0 @@
-texttools/__init__.py,sha256=cI10Q_zaM9DPUCVOM79gZceuyt6Pjgpj3R-AG7xgUM8,778
-texttools/base/__init__.py,sha256=KUGm-Oe0BxlrRhPS-Jm2q1NCmwX8MdtZtloia7bcLaM,189
-texttools/base/base_categorizer.py,sha256=ojup94iXLxh92TjiJmrFXeRbsWKlon7PPAqez96B1bs,1130
-texttools/base/base_keyword_extractor.py,sha256=uKpxb3xI-sim-vXWe1R4_36QRhSNsWDR4IuVdpkZMME,868
-texttools/base/base_ner_extractor.py,sha256=D0LRNSyq1uIU9Qtepi7zpCWWzYz-AOxpVNjq97S1oUA,1933
-texttools/base/base_question_detector.py,sha256=FR9yDP0Z8aAfGafZy3kcpSDUUYWLJM7saRKdeVN5TiM,829
-texttools/base/base_question_generator.py,sha256=L_2ZwqyV9GxsKiQynWKRJG15OBFgQqiCic5H0i8R5yk,3238
-texttools/base/base_question_merger.py,sha256=TYhsihKaIdyGCVu4AcjxPZ1_HocHt__voV8WWGMRpMs,1945
-texttools/base/base_question_rewriter.py,sha256=K6ZnAjxi2qw4yLxm92zTI1IStCfX6c_6lCfIuBDSx8w,1973
-texttools/base/base_router.py,sha256=pFDjIXFqAhPiS9Onu5py_GxOq8geDGJDQh6k6IhCkvw,933
-texttools/base/base_summarizer.py,sha256=7NAilhUPs6ZUwkBpTtXAj6n2XxQH1w6SOolf3gQX2gc,1627
-texttools/base/base_task_performer.py,sha256=3-6qshkie50S7pRG4WHRNC_RdUbSmHOPKW56CD92-rM,1852
-texttools/base/base_translator.py,sha256=BoOxqaoPoUs8t1O3m2yL9pQa5iwisl097immTVcGZoE,1020
-texttools/batch_manager/__init__.py,sha256=3ZkxA395lRD4gNxJ1vp0fNuz_XuBr50GoP51rrwQ0Ks,87
-texttools/batch_manager/batch_manager.py,sha256=jAmKskL3OTYwwsO1mWsWAB3VxMlOF07c2GW1Ev83ZhY,9283
-texttools/batch_manager/batch_runner.py,sha256=kW0IPauI11xpssApMA7b4XI19FePImywym3V7tBaa-o,7404
-texttools/formatter/__init__.py,sha256=KHz2tFZctbit_HVbQNCTMi46JzmKlg-uB6Ost63IpVU,46
-texttools/formatter/base.py,sha256=0fiM6E7NdJevAVpL6yyPaUZVJGKWxE3fr-Ay1oqgJqQ,879
-texttools/formatter/gemma3_formatter.py,sha256=AmdKBYLj6HMsI2DDX4KHNEEVYJmz_VVNUBOv8ScGjsY,1865
-texttools/handlers/__init__.py,sha256=sv0JloipQ57AI0xo-3w9k6cK5rYjZP3ltR2EbBhkHTA,121
-texttools/handlers/handlers.py,sha256=LtC4FBuzRUDy3Jw-Fp21WR-QS1jOcDhsGaMPFQGjfTw,2381
-texttools/handlers/categorizer/__init__.py,sha256=mE05vt_ma6vcP8pQ37BZ85WVQ8jhcjDS0iZV81_LFCY,127
-texttools/handlers/categorizer/categorizer.py,sha256=HBpdhtCGUPl1TJUOxbgSLmVWD7o9xeIjmSWXvYzGrCA,1592
-texttools/tools/__init__.py,sha256=V3ZjSj_ZI9r02sOmxpxxxKBbBbtuYS1MQqtrdGZHC_A,1121
-texttools/tools/categorizer/__init__.py,sha256=VY0SVdik0et0fwLDj7qn-d5LtVqVBIalvlRVci699i4,48
-texttools/tools/categorizer/encoder_model/__init__.py,sha256=7UwoPlQ09VGN0cqfi5fPQRfsZZ8hoZj6fL6cax1BLSU,53
-texttools/tools/categorizer/encoder_model/encoder_vectorizer.py,sha256=MHPVJQJlvNhZ5xLVXk4FtvrORW2yxPSAnjEhjPbkQts,1476
-texttools/tools/categorizer/llm/__init__.py,sha256=0VbxvInITfNUlOF6bJqcUKKaYWlIe9K3vRmIRuvAGcY,95
-texttools/tools/categorizer/llm/gemma_categorizer.py,sha256=tjwKonTjT5cAhxWQaVyvyooRyOlGACHpnn72PNoLk-8,5636
-texttools/tools/categorizer/llm/openai_categorizer.py,sha256=omRk77Z5ZCIAz17h4wPDP_EcBSsscA-PQJpQjtI6--o,2547
-texttools/tools/keyword_extractor/__init__.py,sha256=eTpujS85MmRRbnNwc2ifKUh60W8OG4RQFmWki3Z7C_0,84
-texttools/tools/keyword_extractor/gemma_extractor.py,sha256=TJ4wMPWRuuzRi_Q0hr7UauKhEg8U_5U5j1D_lTFrn4s,4349
-texttools/tools/merger/__init__.py,sha256=bh2RBpqJvDaqEmDrM9y_GcjRqibagifAxiZVu8nEHc0,115
-texttools/tools/merger/gemma_question_merger.py,sha256=JAC-52kBbabIzEWp0MFi9viiu8nZOAMPaJZALHvNMqo,8035
-texttools/tools/ner/__init__.py,sha256=BW84BcItel6Mc2JlaDL6qvAktVMkti67VXceeCnOB1g,70
-texttools/tools/ner/gemma_ner_extractor.py,sha256=YhyIwX_8bdwkFb4gY8g9mZdYHW_r1jCvbmjjNCK9Wfo,5384
-texttools/tools/question_detector/__init__.py,sha256=ulArGttooSoxEe0vUDQSxUQrnsxr7gH9l-LjSER2dVI,162
-texttools/tools/question_detector/gemma_detector.py,sha256=DhlCAA6Hws_OTuYil6UY4sYlbjdQQU6EqHdoTl3a--w,3772
-texttools/tools/question_detector/llm_detector.py,sha256=zo89eh359hqQGGf83-6M22AaiH7q-m0m91SjTyxZaYs,3862
-texttools/tools/question_generator/__init__.py,sha256=EAElpB_YeyMoBqvFNjbW2a_j18SLtiKQ7sRmdS58Fww,61
-texttools/tools/question_generator/gemma_question_generator.py,sha256=V5QcXmHZ5shTvrThOxUrKJ4FqP0P58NIJbsPdyyy5IM,6744
-texttools/tools/reranker/__init__.py,sha256=70jqJ9cjpPzzvnMYgHYGVZ9PrWrN9N97visqD_PVxwU,100
-texttools/tools/reranker/reranker.py,sha256=2SiTMIxempMuHui2n4GJV_2dLGBeoC7WAn_rVVXlMBA,5518
-texttools/tools/reranker/scorer.py,sha256=fQ3Ya8QmNhrcmb-Rf-72hvhweGvVj6gQ4KOlham2eE8,8176
-texttools/tools/reranker/sorter.py,sha256=_ed5zGz7K60skPFFuEQZ1ObBFA71LAfVT6FyWicA-Pw,11419
-texttools/tools/rewriter/__init__.py,sha256=U_qwGeEOqHAcV4p2CHVb0AIvHKFfdvykRzGyWD54aWA,121
-texttools/tools/rewriter/gemma_question_rewriter.py,sha256=jXtRswfBvHn9QmE90JvxEmLvCTbwZqZhD_A5ONWeCzo,7925
-texttools/tools/router/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-texttools/tools/router/gemma_router.py,sha256=VX-kHphZVZNd0_ajugN08hGkWNUeUriwfonpYy2TIS4,5619
-texttools/tools/subject_to_question/__init__.py,sha256=VJpns16Qe5OL_-4WuGDUNShcJsodB2khGWT3Q1Hc-WU,72
-texttools/tools/subject_to_question/gemma_question_generator.py,sha256=VKXHhYHEvhFLUR87iEh0eFpD_4ueX4np8IjF-NkgWrY,7417
-texttools/tools/summarizer/__init__.py,sha256=phrR7qO20CNhO3hjXQBzhTRVumdVdGSufmH4GEYkhj4,140
-texttools/tools/summarizer/gemma_summarizer.py,sha256=ikhsBv7AiZD1dT_d12AyjXxojzSW92e2y5WjchI_3bE,4474
-texttools/tools/summarizer/llm_summerizer.py,sha256=-0rUKbSnl1aDeBfJ5DCSbIlwd2k-9qIaCKgoQJa0hWc,3412
-texttools/tools/translator/__init__.py,sha256=KO1m08J2BZwRqBGO9ICB4l4cnH1jfHLHL5HbgYFUWM8,72
-texttools/tools/translator/gemma_translator.py,sha256=57NMfJAZHQjZSr_eCBePE_Pnag8pu3O00Jicxhzn6Jc,7572
-hamtaa_texttools-0.1.44.dist-info/METADATA,sha256=OImC1zmuJh7p8SY3s3mhm8poOzYOuuqx6vjOeDy5O3k,1481
-hamtaa_texttools-0.1.44.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-hamtaa_texttools-0.1.44.dist-info/top_level.txt,sha256=5Mh0jIxxZ5rOXHGJ6Mp-JPKviywwN0MYuH0xk5bEWqE,10
-hamtaa_texttools-0.1.44.dist-info/RECORD,,

texttools/base/__init__.py

@@ -1,3 +0,0 @@
-from texttools.base.base_categorizer import BaseCategorizer
-from texttools.base.base_question_detector import BaseQuestionDetector
-from texttools.base.base_summarizer import BaseSummarizer