result-companion 0.0.1__py3-none-any.whl

result_companion/core/analizers/local/ollama_server_manager.py

@@ -0,0 +1,185 @@
+import atexit
+import os
+import subprocess
+import time
+from typing import Optional, Type, TypeVar, Union
+
+import requests
+
+from result_companion.core.analizers.local.ollama_exceptions import (
+    OllamaNotInstalled,
+    OllamaServerNotRunning,
+)
+from result_companion.core.utils.logging_config import logger
+
+
+class OllamaServerManager:
+    """
+    Manages the lifecycle of an Ollama server.
+
+    Can be used as a context manager to ensure proper server initialization and cleanup:
+
+    with OllamaServerManager() as server:
+        # Code that requires the Ollama server to be running
+        ...
+    # Server will be automatically cleaned up when exiting the with block
+    """
+
+    def __init__(
+        self,
+        server_url: str = "http://localhost:11434",
+        start_timeout: int = 30,
+        wait_for_start: int = 1,
+        start_cmd: list = ["ollama", "serve"],
+    ):
+        self.server_url = server_url
+        self.start_timeout = start_timeout
+        self._process: Optional[subprocess.Popen] = None
+        self.wait_for_start = wait_for_start
+        self.start_cmd = start_cmd
+        atexit.register(self.cleanup)
+        self._server_started_by_manager = False
+
+    def __enter__(self):
+        """
+        Context manager entry point. Ensures the server is running before proceeding.
+        """
+        if not self.is_running(skip_logs=True):
+            self.start()
+            self._server_started_by_manager = True
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        """
+        Context manager exit point. Cleans up the server if it was started by this manager.
+        """
+        if self._server_started_by_manager:
+            self.cleanup()
+        return False  # Propagate any exceptions
+
+    def is_running(self, skip_logs: bool = False) -> bool:
+        """Checks if the Ollama server is running."""
+        if not skip_logs:
+            logger.debug(
+                f"Checking if Ollama server is running at {self.server_url}..."
+            )
+        try:
+            response = requests.get(self.server_url, timeout=5)
+            return response.status_code == 200 and "Ollama is running" in response.text
+        except requests.exceptions.RequestException:
+            return False
+
+    def _check_process_alive(self) -> None:
+        """
+        Check if the managed process is still alive and raise an exception if it died.
+
+        Raises:
+            OllamaServerNotRunning: If the process has terminated unexpectedly.
+        """
+        if self._process is None:
+            return
+
+        if self._process.poll() is not None:
+            try:
+                _, stderr = self._process.communicate(timeout=1)
+                error_msg = (
+                    stderr.decode().strip()
+                    if stderr
+                    else "Process terminated unexpectedly"
+                )
+            except subprocess.TimeoutExpired:
+                error_msg = "Process terminated unexpectedly"
+            except Exception as e:
+                error_msg = (
+                    f"Process terminated unexpectedly (error reading output: {e})"
+                )
+
+            raise OllamaServerNotRunning(f"Ollama server process died: {error_msg}")
+
+    def start(self) -> None:
+        """
+        Starts the Ollama server if it is not running.
+        Raises:
+            OllamaNotInstalled: If the 'ollama' command is not found.
+            OllamaServerNotRunning: If the server fails to start within the timeout.
+        """
+        if self.is_running(skip_logs=True):
+            logger.debug("Ollama server is already running.")
+            return
+
+        logger.info("Ollama server is not running. Attempting to start it...")
+        try:
+            self._process = subprocess.Popen(
+                self.start_cmd,
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                preexec_fn=os.setsid if os.name != "nt" else None,  # Unix only
+            )
+        except FileNotFoundError:
+            raise OllamaNotInstalled(
+                "Ollama command not found. Ensure it is installed and in your PATH."
+            )
+
+        logger.info(f"Launched 'ollama serve' process with PID: {self._process.pid}")
+
+        # Check if process died immediately after launch
+        time.sleep(0.1)  # Brief pause to let process initialize
+        self._check_process_alive()
+
+        start_time = time.time()
+        while time.time() - start_time < self.start_timeout:
+            if self.is_running(skip_logs=True):
+                logger.info("Ollama server started successfully.")
+                return
+
+            # Check if process died during startup wait
+            self._check_process_alive()
+
+            time.sleep(self.wait_for_start)
+
+        # If the server did not start, clean up and raise an error.
+        self.cleanup()
+        raise OllamaServerNotRunning(
+            f"Failed to start Ollama server within {self.start_timeout}s timeout."
+        )
+
+    def cleanup(self) -> None:
+        """
+        Gracefully terminates the Ollama server, or kills it if necessary.
+        """
+        if self._process is not None:
+            logger.debug(
+                f"Cleaning up Ollama server process with PID: {self._process.pid}"
+            )
+            try:
+                self._process.terminate()
+                self._process.wait(timeout=5)
+                logger.debug("Ollama server terminated gracefully.")
+            except subprocess.TimeoutExpired:
+                self._process.kill()
+                logger.debug("Ollama server killed forcefully.")
+            except Exception as exc:
+                logger.warning(f"Error during Ollama server cleanup: {exc}")
+            self._process = None
+            self._server_started_by_manager = False
+
+
+T = TypeVar("T", bound="OllamaServerManager")
+
+
+def resolve_server_manager(server_manager: Union[Optional[T], Type[T]], **kwargs) -> T:
+    """
+    Resolve a server manager parameter that can be either a class or an instance.
+
+    Args:
+        server_manager: Either an OllamaServerManager instance, a subclass of OllamaServerManager,
+                       or None (in which case a default OllamaServerManager will be created).
+        **kwargs: Additional arguments to pass to the constructor if a new instance is created.
+
+    Returns:
+        An instance of OllamaServerManager or one of its subclasses.
+    """
+    if isinstance(server_manager, type):
+        return server_manager(**kwargs)
+
+    return server_manager or OllamaServerManager(**kwargs)

result_companion/core/analizers/models.py

@@ -0,0 +1,17 @@
+from typing import Callable, Tuple
+
+from langchain_anthropic import ChatAnthropic
+from langchain_aws import BedrockLLM
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_ollama.llms import OllamaLLM
+from langchain_openai import AzureChatOpenAI, ChatOpenAI
+
+MODELS = Tuple[
+    OllamaLLM
+    | AzureChatOpenAI
+    | BedrockLLM
+    | ChatGoogleGenerativeAI
+    | ChatOpenAI
+    | ChatAnthropic,
+    Callable,
+]

result_companion/core/chunking/chunking.py

@@ -0,0 +1,113 @@
+import asyncio
+from typing import Tuple
+
+from langchain.prompts import PromptTemplate
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.runnables import RunnableSerializable
+
+from result_companion.core.analizers.models import MODELS
+from result_companion.core.chunking.utils import Chunking
+from result_companion.core.utils.logging_config import get_progress_logger
+
+logger = get_progress_logger("Chunking")
+
+
+def build_sumarization_chain(
+    prompt: PromptTemplate, model: MODELS
+) -> RunnableSerializable:
+    return prompt | model | StrOutputParser()
+
+
+def split_text_into_chunks_using_text_splitter(
+    text: str, chunk_size: int, overlap: int
+) -> list:
+    splitter = RecursiveCharacterTextSplitter(
+        chunk_size=chunk_size,
+        chunk_overlap=overlap,
+        length_function=len,
+        is_separator_regex=False,
+    )
+    return splitter.split_text(text)
+
+
+async def accumulate_llm_results_for_summarizaton_chain(
+    test_case: dict,
+    chunk_analysis_prompt: str,
+    final_synthesis_prompt: str,
+    chunking_strategy: Chunking,
+    llm: MODELS,
+    chunk_concurrency: int = 1,
+) -> Tuple[str, str, list]:
+    chunks = split_text_into_chunks_using_text_splitter(
+        str(test_case), chunking_strategy.chunk_size, chunking_strategy.chunk_size // 10
+    )
+    return await summarize_test_case(
+        test_case,
+        chunks,
+        llm,
+        chunk_analysis_prompt,
+        final_synthesis_prompt,
+        chunk_concurrency,
+    )
+
+
+async def summarize_test_case(
+    test_case: dict,
+    chunks: list,
+    llm: MODELS,
+    chunk_analysis_prompt: str,
+    final_synthesis_prompt: str,
+    chunk_concurrency: int = 1,
+) -> Tuple[str, str, list]:
+    """Summarizes large test case by analyzing chunks and synthesizing results.
+
+    Args:
+        test_case: Test case dictionary with name and data.
+        chunks: List of text chunks to analyze.
+        llm: Language model instance.
+        chunk_analysis_prompt: Template for analyzing chunks.
+        final_synthesis_prompt: Template for final synthesis.
+        chunk_concurrency: Chunks to process concurrently.
+
+    Returns:
+        Tuple of (final_analysis, test_name, chunks).
+    """
+    logger.info(f"### For test case {test_case['name']}, {len(chunks)=}")
+
+    summarization_prompt = PromptTemplate(
+        input_variables=["text"],
+        template=chunk_analysis_prompt,
+    )
+
+    summarization_chain = build_sumarization_chain(summarization_prompt, llm)
+    semaphore = asyncio.Semaphore(chunk_concurrency)
+    test_name = test_case["name"]
+    total_chunks = len(chunks)
+
+    async def process_with_limit(chunk: str, chunk_idx: int) -> str:
+        async with semaphore:
+            logger.debug(
+                f"[{test_name}] Processing chunk {chunk_idx + 1}/{total_chunks}, length {len(chunk)}"
+            )
+            return await summarization_chain.ainvoke({"text": chunk})
+
+    chunk_tasks = [process_with_limit(chunk, i) for i, chunk in enumerate(chunks)]
+    summaries = await asyncio.gather(*chunk_tasks)
+
+    aggregated_summary = "\n\n---\n\n".join(
+        [
+            f"### Chunk {i+1}/{total_chunks}\n{summary}"
+            for i, summary in enumerate(summaries)
+        ]
+    )
+
+    final_prompt = PromptTemplate(
+        input_variables=["summary"],
+        template=final_synthesis_prompt,
+    )
+
+    final_analysis_chain = build_sumarization_chain(final_prompt, llm)
+    final_result = await final_analysis_chain.ainvoke({"summary": aggregated_summary})
+
+    return final_result, test_case["name"], chunks

result_companion/core/chunking/utils.py

@@ -0,0 +1,114 @@
+import math
+from dataclasses import dataclass
+
+import tiktoken
+
+from result_companion.core.parsers.config import TokenizerModel
+from result_companion.core.utils.logging_config import logger
+
+
+@dataclass
+class Chunking:
+    chunk_size: int
+    number_of_chunks: int
+    raw_text_len: int
+    tokens_from_raw_text: int
+    tokenized_chunks: int
+
+
+def azure_openai_tokenizer(text: str) -> int:
+    """Tokenizer for Azure OpenAI models using tiktoken."""
+    # TODO: check if not starting something on import
+    encoding = tiktoken.encoding_for_model("gpt-3.5-turbo")
+    return len(encoding.encode(text))
+
+
+def ollama_tokenizer(text: str) -> int:
+    """Placeholder tokenizer for Ollama (custom implementation required)."""
+    return len(text) // 4
+
+
+def bedrock_tokenizer(text: str) -> int:
+    """Placeholder tokenizer for Bedrock LLM (custom implementation required)."""
+    return len(text) // 5
+
+
+def google_tokenizer(text: str) -> int:
+    """Tokenizer for Google Generative AI models.
+
+    Google's tokenization is approximately 4 characters per token on average,
+    but we use the tiktoken cl100k_base encoding which is close to Google's tokenization.
+    """
+    try:
+        # Use cl100k_base encoding which is similar to Google's tokenization
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.warning(f"Failed to use cl100k_base encoding for Google tokenizer: {e}")
+        # Fallback to approximate tokenization (4 chars per token)
+        return len(text) // 4
+
+
+def anthropic_tokenizer(text: str) -> int:
+    """Tokenizer for Anthropic Claude models.
+
+    Uses cl100k_base encoding as approximation for Claude tokenization.
+    """
+    try:
+        encoding = tiktoken.get_encoding("cl100k_base")
+        return len(encoding.encode(text))
+    except Exception as e:
+        logger.warning(
+            f"Failed to use cl100k_base encoding for Anthropic tokenizer: {e}"
+        )
+        return len(text) // 4
+
+
+tokenizer_mappings = {
+    "azure_openai_tokenizer": azure_openai_tokenizer,
+    "ollama_tokenizer": ollama_tokenizer,
+    "bedrock_tokenizer": bedrock_tokenizer,
+    "google_tokenizer": google_tokenizer,
+    "openai_tokenizer": azure_openai_tokenizer,  # Same tokenization as Azure
+    "anthropic_tokenizer": anthropic_tokenizer,
+}
+
+
+def calculate_overall_chunk_size(
+    raw_text: str, actual_tokens_from_text: int, max_tokens_acceptable: int
+) -> Chunking:
+    raw_text_len = len(raw_text)
+    N_tokenized_chunks = math.ceil(actual_tokens_from_text / max_tokens_acceptable)
+    if max_tokens_acceptable > actual_tokens_from_text:
+        return Chunking(
+            chunk_size=0,
+            number_of_chunks=0,
+            raw_text_len=raw_text_len,
+            tokens_from_raw_text=actual_tokens_from_text,
+            tokenized_chunks=N_tokenized_chunks,
+        )
+    chunk_size = raw_text_len / N_tokenized_chunks
+    logger.info(
+        f"Chunk size: {chunk_size}, Number of chunks: {N_tokenized_chunks}, Raw text length: {raw_text_len}"
+    )
+    return Chunking(
+        chunk_size=chunk_size,
+        number_of_chunks=N_tokenized_chunks,
+        raw_text_len=raw_text_len,
+        tokens_from_raw_text=actual_tokens_from_text,
+        tokenized_chunks=N_tokenized_chunks,
+    )
+
+
+def calculate_chunk_size(
+    test_case: dict, system_prompt: str, tokenizer_from_config: TokenizerModel
+) -> Chunking:
+    LLM_fed_text = str(test_case) + system_prompt
+    tokenizer = tokenizer_mappings[tokenizer_from_config.tokenizer]
+    max_content_tokens = tokenizer_from_config.max_content_tokens
+    text_to_tokens = tokenizer(LLM_fed_text)
+    return calculate_overall_chunk_size(
+        actual_tokens_from_text=text_to_tokens,
+        max_tokens_acceptable=max_content_tokens,
+        raw_text=LLM_fed_text,
+    )

result_companion/core/configs/default_config.yaml

@@ -0,0 +1,85 @@
+version: 1.0
+
+test_filter:
+  include_tags: []
+  exclude_tags: []
+  include_passing: false
+
+llm_config:
+  question_prompt: |
+    You analyze Robot Framework test failures in JSON format.
+    Structure: test → keywords (recursive) → name, args, messages, status.
+
+    ANALYSIS PRIORITY:
+    1. Find keywords with status="FAIL" - start there
+    2. Check preceding PASS keywords for setup issues
+    3. Look for: tracebacks, exceptions, assertion errors, timeouts
+    4. Cascading failures: find the FIRST failure, not symptoms
+
+    RESPOND EXACTLY IN THIS FORMAT (be terse):
+
+    **Flow**
+    - [Only keywords leading to failure. Max 5 bullets]
+
+    **Root Cause**
+    [Keyword name in quotes. Error type. Why it failed. Max 2-3 sentences]
+    Confidence: HIGH/MEDIUM/LOW
+
+    **Fix**
+    - [Actionable fix for test code or environment. Max 1-2 bullets]
+
+    NO PREAMBLE. NO REASONING. DIRECT ANSWER ONLY.
+
+  chunking:
+    chunk_analysis_prompt: |
+      EXTRACT failure-relevant info from this Robot Framework test chunk.
+
+      OUTPUT FORMAT (use exactly):
+      ERRORS: [any exceptions, tracebacks, assertion failures - quote exact text]
+      FAIL_KEYWORDS: [keyword names with status=FAIL, in order]
+      SUSPECT_KEYWORDS: [PASS keywords with warnings/errors in messages]
+      NOTES: [one line only - anything else relevant, or "none"]
+
+      If chunk has no errors/failures: respond only "CLEAN: no issues"
+
+      {text}
+
+    final_synthesis_prompt: |
+      NO PREAMBLE. NO REASONING. DIRECT OUTPUT ONLY.
+
+      Synthesize chunk summaries into final analysis.
+      Ignore CLEAN chunks. Deduplicate repeated errors.
+      Find the FIRST failure in execution order - that's the root cause.
+
+      **Flow**
+      - [Only failure-path keywords from all chunks. Max 5 bullets]
+
+      **Root Cause**
+      [First failing keyword in quotes. Error type. Why. Max 2-3 sentences]
+      Confidence: HIGH/MEDIUM/LOW
+
+      **Fix**
+      - [Actionable fix. Max 1-2 bullets]
+
+      {summary}
+
+  prompt_template: |
+    Question: {question}
+
+    Answer the question based on the following context: {context}
+
+llm_factory:
+  model_type: "OllamaLLM" # AzureChatOpenAI OllamaLLM BedrockLLM
+  parameters:
+    model: "deepseek-r1:1.5b"
+  strategy:
+    parameters:
+      model_name: "deepseek-r1"
+
+tokenizer:
+  tokenizer: ollama_tokenizer
+  max_content_tokens: 140000
+
+concurrency:
+  test_case: 1
+  chunk: 1