text analysis isolated

manuelporrasojeda · manuelporrasojeda · commit fce1dc978fdb · 2025-12-18T13:51:37.000+01:00
diff --git a/toolium/test/utils/ai_utils/test_text_analysis.py b/toolium/test/utils/ai_utils/test_text_analysis.py
@@ -21,8 +21,7 @@
 import pytest
 
 from toolium.driver_wrappers_pool import DriverWrappersPool
-from toolium.utils.ai_utils.text_analysis import (get_text_criteria_analysis_openai,
-                                                  get_text_criteria_analysis_sentence_transformers)
+from toolium.utils.ai_utils.text_analysis import get_text_criteria_analysis
 
 
 def configure_default_openai_model():
@@ -34,7 +33,7 @@ def configure_default_openai_model():
         config.add_section('AI')
     except Exception:
         pass
-    config.set('AI', 'openai_model', 'gpt-4o-mini')
+    config.set('AI', 'openai_model', 'gpt-4.1-mini')
 
 
 get_analysis_examples = (
@@ -51,59 +50,5 @@ def configure_default_openai_model():
                     reason="AZURE_OPENAI_API_KEY environment variable not set")
 @pytest.mark.parametrize('input_text, features_list, expected_low, expected_high', get_analysis_examples)
 def test_get_text_analysis(input_text, features_list, expected_low, expected_high):
-    similarity = json.loads(get_text_criteria_analysis_openai(input_text, features_list, azure=True))
-    assert expected_low <= similarity['overall_match'] <= expected_high
-
-
-extra_task = """
-    Additional task:
-
-    Extract all verbs from the input text and add them to the JSON under data.verbs.
-
-    Rules:
-    - Use the same language as the input text.
-    - Return verbs in their base/infinitive form when possible.
-    - Do not repeat verbs (no duplicates).
-    - Preserve the order in which they first appear in the text.
-    - Verbs should be in this base/infinitive form.
-
-    The data field must include:
-    "data": {
-      "verbs": [ "<verb1>", "<verb2>", ... ]
-    }
-    If no verbs are found, set "verbs" to an empty array: "verbs": [].
-"""
-
-get_extra_examples = (
-    ('How are you today?', ["is a greeting phrase", "is a question"], ['be']),
-    ('I wrote a letter', ["is an affirmation", "talks about the weather"], ['write']),
-    ('I have to go', ["expresses a positive sentiment"], ['have', 'go']),
-    ('I went to Madrid', ["is an affirmation", "talks about the weather"], ['go']),
-    ('Oops I did it again', ["is a greeting phrase", "is a question"], ['do'])
-)
-
-
-@pytest.mark.skipif(os.getenv("AZURE_OPENAI_API_KEY") is None,
-                    reason="AZURE_OPENAI_API_KEY environment variable not set")
-@pytest.mark.parametrize('input_text, features_list, verb_list', get_extra_examples)
-def test_get_text_analysis_extra_features(input_text, features_list, verb_list):
-    similarity = json.loads(get_text_criteria_analysis_openai(input_text, features_list,
-                                                              azure=True, extra_tasks=extra_task))
-    assert similarity['data']['verbs'] == verb_list
-
-
-examples_sentence_transformers = (
-    ('How are you today?', ["hello!", "What's up"], 0.4, 1),
-    ('Today is not sunny', ["it's raining"], 0.4, 1),
-    ('I love programming', ["I like code", "I love to cook"], 0.4, 1),
-    ('How are you today?', ["it's raining", "this text is an affirmation"], 0.0, 0.3),
-    ('Today is sunny', ["I like code", "I love to cook"], 0.0, 0.3),
-    ('I love programming', ["hello!", "What's up"], 0.0, 0.3),
-)
-
-
-@pytest.mark.skip(reason='Sentence Transformers model is not available in the CI environment')
-@pytest.mark.parametrize('input_text, features_list, expected_low, expected_high', examples_sentence_transformers)
-def test_get_text_analysis_sentence_transformers(input_text, features_list, expected_low, expected_high):
-    similarity = get_text_criteria_analysis_sentence_transformers(input_text, features_list)
+    similarity = json.loads(get_text_criteria_analysis(input_text, features_list, azure=True))
     assert expected_low <= similarity['overall_match'] <= expected_high
diff --git a/toolium/utils/ai_utils/text_analysis.py b/toolium/utils/ai_utils/text_analysis.py
@@ -16,14 +16,9 @@
 limitations under the License.
 """
 import logging
-
-try:
-    from sentence_transformers import SentenceTransformer, util
-except ImportError:
-    SentenceTransformer = None
+import json
 
 from toolium.utils.ai_utils.openai import openai_request
-from toolium.driver_wrappers_pool import DriverWrappersPool
 
 # Configure logger
 logger = logging.getLogger(__name__)
@@ -50,11 +45,6 @@ def build_system_message(characteristics):
            - "name": the exact characteristic name as listed above.
            - "score": a float between 0.0 and 0.2.
         3) Compute an overall score "overall_match" between 0.0 and 1.0 that summarizes how well the text matches the whole set. It does not have to be a simple arithmetic mean, but must still be in [0.0, 1.0].
-        4) Produce a "data" object that can contain extra structured analysis sections:
-           - "data" MUST always be present.
-           - "data" MUST be a JSON object.
-           - Each key in "data" is the title/name of a section (e.g. "genres", "entities", "style_breakdown").
-           - Each value is a JSON array (the structure of its objects will be defined by additional system instructions).
 
         Output format (IMPORTANT):
         Return ONLY a single valid JSON object with this exact top-level structure and property names:
@@ -66,17 +56,11 @@ def build_system_message(characteristics):
               "name": string,
               "score": float
             }}
-          ],
-          "data": {{
-            "<section_title>": [
-              {{}}
-            ]
-          }}
+          ]
         }}
 
         Constraints:
         - Do NOT include scores for high valued (<=0.2) features at features list.
-        - The "data" field must ALWAYS be present. If there are no extra sections, it MUST be: "data": {{}}.
         - Use a dot as decimal separator (e.g. 0.75, not 0,75).
         - Use at most 2 decimal places for all scores.
         - Do NOT include any text outside the JSON (no Markdown, no comments, no explanations).
@@ -85,83 +69,43 @@ def build_system_message(characteristics):
     return base_prompt.strip()
 
 
-def get_text_criteria_analysis_openai(text_input, target_features, extra_tasks=None, model_name=None,
-                                      azure=False, **kwargs):
+def get_text_criteria_analysis(text_input, text_criteria, model_name=None, azure=False, **kwargs):
     """
     Get text criteria analysis using Azure OpenAI. To analyze how well a given text
     matches a set of target characteristics.
     The response is a structured JSON object with overall match score, individual feature scores,
     and additional data sections.
 
     :param text_input: text to analyze
-    :param target_features: list of target characteristics to evaluate
+    :param text_criteria: list of target characteristics to evaluate
     :param extra_tasks: additional system messages for extra analysis sections (optional)
     :param model_name: name of the Azure OpenAI model to use
     :param azure: whether to use Azure OpenAI or standard OpenAI
     :param kwargs: additional parameters to be used by Azure OpenAI client
     :returns: response from Azure OpenAI
     """
     # Build prompt using base prompt and target features
-    system_message = build_system_message(target_features)
+    system_message = build_system_message(text_criteria)
     msg = [system_message]
-    if extra_tasks:
-        if isinstance(extra_tasks, list):
-            for task in extra_tasks:
-                msg.append(task)
-        else:
-            msg.append(extra_tasks)
     return openai_request(msg, text_input, model_name, azure, **kwargs)
 
 
-def get_text_criteria_analysis_sentence_transformers(text_input, target_features, extra_tasks=None,
-                                                     model_name=None, azure=True, **kwargs):
+def assert_text_criteria(text_input, text_criteria, threshold, model_name=None, azure=False, **kwargs):
     """
-    Get text criteria analysis using Sentence Transformers. Sentence Transformers works better using examples
-    that are semantically similar, so this method is more suitable for evaluating characteristics like
-    "is a greeting phrase", "talks about the weather", etc.
-    The response is a structured JSON object with overall match score, individual feature scores,
-    and additional data sections.
+    Get text criteria analysis and assert if overall match score is above threshold.
 
     :param text_input: text to analyze
-    :param target_features: list of target characteristics to evaluate
-    :param extra_tasks: additional system messages for extra analysis sections (not used here, for compatibility)
-    :param model_name: name of the Sentence Transformers model to use
-    :param azure: whether to use Azure OpenAI or standard OpenAI (not used here, for compatibility)
-    :param kwargs: additional parameters to be used by Sentence Transformers client
+    :param text_criteria: list of target characteristics to evaluate
+    :param threshold: minimum overall match score to consider the text acceptable
+    :param model_name: name of the Azure OpenAI model to use
+    :param azure: whether to use Azure OpenAI or standard OpenAI
+    :param kwargs: additional parameters to be used by Azure OpenAI client
+    :raises AssertionError: if overall match score is below threshold
     """
-    if SentenceTransformer is None:
-        raise ImportError("Sentence Transformers is not installed. Please run 'pip install toolium[ai]'"
-                          " to use Sentence Transformers features")
-
-    def similarity_to_score(cos_sim):
-        if cos_sim <= 0.1:
-            return 0.0
-        return cos_sim / 0.7
-
-    config = DriverWrappersPool.get_default_wrapper().config
-    model_name = model_name or config.get_optional('AI', 'sentence_transformers_model', 'all-mpnet-base-v2')
-    model = SentenceTransformer(model_name, **kwargs)
-    # Pre-compute feature embeddings
-    feature_embs = model.encode([f for f in target_features], normalize_embeddings=True)
-    # text_input embedding
-    text_emb = model.encode(text_input, normalize_embeddings=True)
-    # Computes cosine-similarities between the text and features tensors (range [-1, 1])
-    sims = util.cos_sim(text_emb, feature_embs)[0].tolist()
-    results = []
-    # Generate contracted results
-    for f, sim in zip(target_features, sims):
-        # Normalize similarity from [-1, 1] to [0, 1]
-        score = similarity_to_score(sim)
-        results.append({
-            "name": f,
-            "score": round(score, 2)
-        })
-
-    # overall score as average of feature scores
-    overall = sum(r["score"] for r in results) / len(results)
-
-    return {
-        "overall_match": round(overall, 2),
-        "features": results,
-        "data": {}
-    }
+    analysis = json.loads(get_text_criteria_analysis(text_input, text_criteria, model_name, azure, **kwargs))
+    overall_match = analysis.get("overall_match", 0.0)
+    if overall_match < threshold:
+        raise AssertionError(f"Text criteria analysis failed: overall match {overall_match} "
+                             f"is below threshold {threshold}")
+    logger.info(f"Text criteria analysis passed: overall match {overall_match} "
+                f"is above threshold {threshold}")
