result-companion 0.0.1__py3-none-any.whl

result_companion/__init__.py

@@ -0,0 +1,8 @@
+"""Result Companion - AI-powered Robot Framework test analysis."""
+
+try:
+    from importlib.metadata import version
+
+    __version__ = version("result-companion")
+except Exception:  # pragma: no cover
+    __version__ = "0.0.0"

result_companion/core/analizers/common.py

@@ -0,0 +1,58 @@
+import asyncio
+from typing import Tuple
+
+from langchain_core.runnables import RunnableSerializable
+
+
+async def accumulate_llm_results(
+    test_case: list, question_from_config_file: str, chain: RunnableSerializable
+) -> Tuple[str, str]:
+    print(
+        f"\n### Test Case: {test_case['name']}, content length: {len(str(test_case))}"
+    )
+    result = []
+    async for chunk in chain.astream(
+        {"context": test_case, "question": question_from_config_file}, verbose=True
+    ):
+        result.append(chunk)
+        print(chunk, end="", flush=True)
+    return "".join(result), test_case["name"]
+
+
+async def run_llm_based_analysis_and_stream_results(
+    test_cases: list, question_from_config_file: str, chain: RunnableSerializable
+) -> dict:
+
+    llm_results = dict()
+    for test_case in test_cases:
+        llm_results[test_case["name"]], _ = await accumulate_llm_results(
+            test_case, question_from_config_file, chain
+        )
+
+    return llm_results
+
+
+async def run_with_semaphore(semaphore: asyncio.Semaphore, coroutine: any) -> any:
+    async with semaphore:
+        return await coroutine
+
+
+async def run_llm_api_calls_based_analysis_and_stream_results(
+    test_cases: list, question_from_config_file: str, chain: RunnableSerializable
+) -> dict:
+    llm_results = dict()
+    corutines = []
+
+    for test_case in test_cases:
+        corutines.append(
+            accumulate_llm_results(test_case, question_from_config_file, chain)
+        )
+
+    semaphore = asyncio.Semaphore(1)  # Limit concurrency
+
+    tasks = [run_with_semaphore(semaphore, coroutine) for coroutine in corutines]
+
+    for result, name in await asyncio.gather(*tasks):
+        llm_results[name] = result
+
+    return llm_results

result_companion/core/analizers/factory_common.py

@@ -0,0 +1,104 @@
+import asyncio
+from typing import Callable, Tuple
+
+from langchain_anthropic import ChatAnthropic
+from langchain_aws import BedrockLLM
+from langchain_core.output_parsers import StrOutputParser
+from langchain_core.prompts import ChatPromptTemplate
+from langchain_google_genai import ChatGoogleGenerativeAI
+from langchain_ollama.llms import OllamaLLM
+from langchain_openai import AzureChatOpenAI, ChatOpenAI
+
+from result_companion.core.chunking.chunking import (
+    accumulate_llm_results_for_summarizaton_chain,
+)
+from result_companion.core.chunking.utils import calculate_chunk_size
+from result_companion.core.parsers.config import DefaultConfigModel
+from result_companion.core.utils.logging_config import get_progress_logger
+from result_companion.core.utils.progress import run_tasks_with_progress
+
+logger = get_progress_logger("Analyzer")
+
+MODELS = Tuple[
+    OllamaLLM
+    | AzureChatOpenAI
+    | BedrockLLM
+    | ChatGoogleGenerativeAI
+    | ChatOpenAI
+    | ChatAnthropic,
+    Callable,
+]
+
+
+async def accumulate_llm_results_without_streaming(
+    test_case: dict,
+    question_from_config_file: str,
+    prompt: ChatPromptTemplate,
+    model: MODELS,
+) -> Tuple[str, str, list]:
+    logger.info(
+        f"### Test Case: {test_case['name']}, content length: {len(str(test_case))}"
+    )
+    chain = prompt | model | StrOutputParser()
+    return (
+        await chain.ainvoke(
+            {"context": test_case, "question": question_from_config_file}, verbose=True
+        ),
+        test_case["name"],
+        [],
+    )
+
+
+async def execute_llm_and_get_results(
+    test_cases: list,
+    config: DefaultConfigModel,
+    prompt: ChatPromptTemplate,
+    model: MODELS,
+) -> dict:
+    question_from_config_file = config.llm_config.question_prompt
+    tokenizer = config.tokenizer
+    test_case_concurrency = config.concurrency.test_case
+    chunk_concurrency = config.concurrency.chunk
+    chunk_analysis_prompt = config.llm_config.chunking.chunk_analysis_prompt
+    final_synthesis_prompt = config.llm_config.chunking.final_synthesis_prompt
+
+    llm_results = dict()
+    corutines = []
+    logger.info(
+        f"Executing chain, {len(test_cases)=}, {test_case_concurrency=}, {chunk_concurrency=}"
+    )
+
+    for test_case in test_cases:
+        raw_test_case_text = str(test_case)
+        chunk = calculate_chunk_size(
+            raw_test_case_text, question_from_config_file, tokenizer
+        )
+
+        # TODO: zero chunk size seems magical
+        if chunk.chunk_size == 0:
+            corutines.append(
+                accumulate_llm_results_without_streaming(
+                    test_case, question_from_config_file, prompt, model
+                )
+            )
+        else:
+            corutines.append(
+                accumulate_llm_results_for_summarizaton_chain(
+                    test_case=test_case,
+                    chunk_analysis_prompt=chunk_analysis_prompt,
+                    final_synthesis_prompt=final_synthesis_prompt,
+                    chunking_strategy=chunk,
+                    llm=model,
+                    chunk_concurrency=chunk_concurrency,
+                )
+            )
+
+    semaphore = asyncio.Semaphore(test_case_concurrency)
+
+    desc = f"Analyzing {len(test_cases)} test cases"
+    results = await run_tasks_with_progress(corutines, semaphore=semaphore, desc=desc)
+
+    for result, name, chunks in results:
+        llm_results[name] = result
+
+    return llm_results

result_companion/core/analizers/local/ollama_exceptions.py

@@ -0,0 +1,10 @@
+class OllamaServerNotRunning(Exception):
+    """Exception raised when Ollama server is not running."""
+
+
+class OllamaNotInstalled(Exception):
+    """Exception raised when Ollama is not installed."""
+
+
+class OllamaModelNotAvailable(Exception):
+    """Exception raised when the required Ollama model is not available."""

result_companion/core/analizers/local/ollama_install.py

@@ -0,0 +1,279 @@
+import platform
+import shutil
+import subprocess
+from abc import ABC, abstractmethod
+from dataclasses import dataclass
+from enum import Enum, auto
+from typing import List
+
+from result_companion.core.utils.logging_config import logger
+
+
+class PlatformType(Enum):
+    MACOS = auto()
+    LINUX_DEBIAN = auto()
+    LINUX_RHEL = auto()
+    LINUX_ARCH = auto()
+    WINDOWS = auto()
+    UNSUPPORTED = auto()
+
+
+class OllamaInstallationError(Exception):
+    pass
+
+
+class ModelInstallationError(Exception):
+    pass
+
+
+@dataclass
+class InstallConfig:
+    """Installation configuration for a platform."""
+
+    commands: List[List[str]]
+    prerequisite_check: str  # Command to check if prerequisite exists
+
+
+class BaseInstaller(ABC):
+    """Simplified base installer."""
+
+    def __init__(self):
+        self.config = self.get_config()
+
+    @abstractmethod
+    def get_config(self) -> InstallConfig:
+        """Get installation configuration."""
+        pass
+
+    def validate_prerequisites(self) -> bool:
+        """Check if prerequisites are available."""
+        return shutil.which(self.config.prerequisite_check) is not None
+
+    def install(self) -> None:
+        """Install Ollama."""
+        if not self.validate_prerequisites():
+            raise OllamaInstallationError(
+                f"Missing prerequisite: {self.config.prerequisite_check}"
+            )
+
+        for cmd in self.config.commands:
+            logger.info(f"Executing: {' '.join(cmd)}")
+            subprocess.run(cmd, check=True, capture_output=True, text=True)
+
+
+class MacOSInstaller(BaseInstaller):
+    def get_config(self) -> InstallConfig:
+        return InstallConfig(
+            commands=[["brew", "install", "ollama"]], prerequisite_check="brew"
+        )
+
+
+class DebianInstaller(BaseInstaller):
+    def get_config(self) -> InstallConfig:
+        return InstallConfig(
+            commands=[
+                ["curl", "-fsSL", "https://ollama.com/install.sh"],
+                ["sh", "-c", "curl -fsSL https://ollama.com/install.sh | sh"],
+            ],
+            prerequisite_check="curl",
+        )
+
+
+class RHELInstaller(BaseInstaller):
+    def get_config(self) -> InstallConfig:
+        return InstallConfig(
+            commands=[
+                ["curl", "-fsSL", "https://ollama.com/install.sh"],
+                ["sh", "-c", "curl -fsSL https://ollama.com/install.sh | sh"],
+            ],
+            prerequisite_check="curl",
+        )
+
+
+class ArchInstaller(BaseInstaller):
+    def get_config(self) -> InstallConfig:
+        return InstallConfig(
+            commands=[["sudo", "pacman", "-Sy", "--noconfirm", "ollama"]],
+            prerequisite_check="pacman",
+        )
+
+
+class WindowsInstaller(BaseInstaller):
+    def get_config(self) -> InstallConfig:
+        return InstallConfig(
+            commands=[
+                [
+                    "powershell",
+                    "-Command",
+                    "Invoke-WebRequest -Uri https://ollama.com/download/windows -OutFile $env:TEMP\\ollama-installer.exe",
+                ],
+                [
+                    "powershell",
+                    "-Command",
+                    "Start-Process -FilePath $env:TEMP\\ollama-installer.exe -ArgumentList '/S' -Wait",
+                ],
+            ],
+            prerequisite_check="powershell",
+        )
+
+
+class OllamaManager:
+    """Simplified Ollama installation and model manager."""
+
+    _INSTALLERS = {
+        PlatformType.MACOS: MacOSInstaller,
+        PlatformType.LINUX_DEBIAN: DebianInstaller,
+        PlatformType.LINUX_RHEL: RHELInstaller,
+        PlatformType.LINUX_ARCH: ArchInstaller,
+        PlatformType.WINDOWS: WindowsInstaller,
+    }
+
+    def __init__(self):
+        self.platform = self._detect_platform()
+
+    def _detect_platform(self) -> PlatformType:
+        """Detect current platform."""
+        system = platform.system().lower()
+
+        if system == "darwin":
+            return PlatformType.MACOS
+        elif system == "windows":
+            return PlatformType.WINDOWS
+        elif system == "linux":
+            return self._detect_linux_distro()
+        else:
+            return PlatformType.UNSUPPORTED
+
+    def _detect_linux_distro(self) -> PlatformType:
+        """Detect Linux distribution."""
+        try:
+            with open("/etc/os-release", "r") as f:
+                content = f.read().lower()
+                if any(x in content for x in ["ubuntu", "debian"]):
+                    return PlatformType.LINUX_DEBIAN
+                elif any(x in content for x in ["rhel", "centos", "fedora"]):
+                    return PlatformType.LINUX_RHEL
+                elif "arch" in content:
+                    return PlatformType.LINUX_ARCH
+        except FileNotFoundError:
+            pass
+
+        # Fallback to package manager detection
+        if shutil.which("apt"):
+            return PlatformType.LINUX_DEBIAN
+        if shutil.which("yum") or shutil.which("dnf"):
+            return PlatformType.LINUX_RHEL
+        if shutil.which("pacman"):
+            return PlatformType.LINUX_ARCH
+
+        return PlatformType.LINUX_DEBIAN  # Default
+
+    def _run_command(
+        self, cmd: List[str], stream_output: bool = False
+    ) -> subprocess.CompletedProcess:
+        """Run command with optional streaming."""
+        if stream_output:
+            return self._run_with_streaming(cmd)
+        # TOOD: remove this since streaming is always used
+        return subprocess.run(cmd, capture_output=True, text=True, check=True)
+
+    def _run_with_streaming(self, cmd: List[str]) -> subprocess.CompletedProcess:
+        """Run command with real-time output streaming."""
+        logger.info(f"Running: {' '.join(cmd)}")
+
+        process = subprocess.Popen(
+            cmd,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.STDOUT,
+            text=True,
+            bufsize=1,
+            universal_newlines=True,
+        )
+
+        output_lines = []
+        for line in iter(process.stdout.readline, ""):
+            line = line.rstrip()
+            if line:
+                logger.info(f"Ollama: {line}")
+                output_lines.append(line)
+
+        return_code = process.wait()
+        result = subprocess.CompletedProcess(
+            cmd, return_code, "\n".join(output_lines), ""
+        )
+
+        if return_code != 0:
+            raise subprocess.CalledProcessError(
+                return_code, cmd, "\n".join(output_lines)
+            )
+
+        return result
+
+    def is_ollama_installed(self) -> bool:
+        """Check if Ollama is installed."""
+        try:
+            self._run_command(["ollama", "--version"])
+            return True
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+
+    def is_model_installed(self, model_name: str) -> bool:
+        """Check if model is installed."""
+        try:
+            result = self._run_command(["ollama", "list"])
+            return model_name in result.stdout
+        except (subprocess.SubprocessError, FileNotFoundError):
+            return False
+
+    def install_ollama(self) -> bool:
+        """Install Ollama if not already installed."""
+        if self.is_ollama_installed():
+            logger.info("Ollama already installed.")
+            return True
+
+        if self.platform == PlatformType.UNSUPPORTED:
+            raise OllamaInstallationError(f"Unsupported platform: {platform.system()}")
+
+        logger.info("Installing Ollama...")
+
+        try:
+            installer_class = self._INSTALLERS[self.platform]
+            installer = installer_class()
+            installer.install()
+        except Exception as e:
+            raise OllamaInstallationError(f"Installation failed: {str(e)}") from e
+
+        if not self.is_ollama_installed():
+            raise OllamaInstallationError("Installation verification failed")
+
+        logger.info("Ollama installed successfully!")
+        return True
+
+    def install_model(self, model_name: str) -> bool:
+        """Install model if not already installed."""
+        if self.is_model_installed(model_name):
+            logger.info(f"Model '{model_name}' already installed.")
+            return True
+
+        logger.info(f"Installing model '{model_name}'...")
+
+        try:
+            self._run_command(["ollama", "pull", model_name], stream_output=True)
+        except Exception as e:
+            raise ModelInstallationError(f"Model installation failed: {str(e)}") from e
+
+        if not self.is_model_installed(model_name):
+            raise ModelInstallationError("Model installation verification failed")
+
+        logger.info(f"Model '{model_name}' installed successfully!")
+        return True
+
+
+def auto_install_ollama() -> bool:
+    """Auto-install Ollama."""
+    return OllamaManager().install_ollama()
+
+
+def auto_install_model(model_name: str) -> bool:
+    """Auto-install model."""
+    return OllamaManager().install_model(model_name)

result_companion/core/analizers/local/ollama_runner.py

@@ -0,0 +1,124 @@
+import subprocess
+from typing import Optional, Type, Union
+
+from result_companion.core.analizers.local.ollama_exceptions import (
+    OllamaModelNotAvailable,
+    OllamaNotInstalled,
+    OllamaServerNotRunning,
+)
+from result_companion.core.analizers.local.ollama_server_manager import (
+    OllamaServerManager,
+    resolve_server_manager,
+)
+from result_companion.core.utils.logging_config import logger
+
+
+# TODO: move to different location > ollama_install
+def check_ollama_installed(ollama_version_cmd: list = ["ollama", "--version"]) -> None:
+    logger.debug("Checking if Ollama is installed...")
+    try:
+        result = subprocess.run(
+            ollama_version_cmd, capture_output=True, text=True, check=True
+        )
+        logger.debug(f"Ollama installed: {result.stdout.strip()}")
+    except FileNotFoundError:
+        raise OllamaNotInstalled(
+            "Ollama command not found. Ensure it is installed and in your PATH."
+        )
+    except subprocess.CalledProcessError as exc:
+        raise OllamaNotInstalled(f"Ollama command failed: {exc}.")
+    except Exception as exc:
+        raise OllamaNotInstalled(f"Failed to check Ollama installation: {exc}") from exc
+    logger.debug("Ollama installation check passed.")
+
+
+def check_model_installed(
+    model_name: str, ollama_list_cmd: list = ["ollama", "list"]
+) -> None:
+    logger.debug(f"Checking if model '{model_name}' is installed...")
+    try:
+        result = subprocess.run(
+            ollama_list_cmd, capture_output=True, text=True, check=True
+        )
+    except subprocess.CalledProcessError as exc:
+        raise OllamaServerNotRunning(
+            f"'ollama list' command failed with error code {exc.returncode}: {exc.stderr}"
+        ) from exc
+    if not any(
+        line.startswith(f"{model_name}:") or line.startswith(f"{model_name} ")
+        for line in result.stdout.splitlines()
+    ):
+        raise OllamaModelNotAvailable(
+            f"Model '{model_name}' is not installed in Ollama. Run `ollama pull {model_name}`."
+        )
+    logger.debug(f"Model '{model_name}' is installed.")
+
+
+def ollama_on_init_strategy(
+    model_name: str,
+    server_url: str = "http://localhost:11434",
+    start_timeout: int = 30,
+    server_manager: Union[
+        Optional["OllamaServerManager"], Type["OllamaServerManager"]
+    ] = OllamaServerManager,
+) -> "OllamaServerManager":
+    """
+    Initialize Ollama by ensuring it is installed, the server is running,
+    and the specified model is available.
+
+    Parameters:
+        model_name (str): Name of the model to check.
+        server_url (str): URL where the server is expected.
+        start_timeout (int): Timeout for starting the server.
+        server_manager (Union[OllamaServerManager, Type[OllamaServerManager]]):
+            Either an instance of OllamaServerManager to use directly,
+            or the OllamaServerManager class (or subclass) to instantiate.
+            Defaults to the OllamaServerManager class.
+
+    Returns:
+        OllamaServerManager: The server manager instance that was used.
+
+    Raises:
+        OllamaNotInstalled: If Ollama is not installed.
+        OllamaServerNotRunning: If the server fails to start.
+        OllamaModelNotInstalled: If the specified model is not installed.
+    """
+    check_ollama_installed()
+
+    server_manager_instance = resolve_server_manager(
+        server_manager, server_url=server_url, start_timeout=start_timeout
+    )
+
+    if not server_manager_instance.is_running():
+        server_manager_instance.start()
+    else:
+        logger.debug("Ollama server is already running.")
+    logger.debug(f"Ollama server is confirmed running at {server_url}")
+    check_model_installed(model_name)
+    return server_manager_instance
+
+
+if __name__ == "__main__":
+    # TODO: Transfer to integration tests
+    import logging
+
+    from langchain_ollama.llms import OllamaLLM
+
+    logging.basicConfig(level=logging.INFO)
+    test_model = "deepseek-r1"  # Change to a model you might have/not have
+    try:
+        server_mnger = ollama_on_init_strategy(test_model)
+        print(f"Successfully verified Ollama setup for model: {test_model}")
+    except (OllamaNotInstalled, OllamaServerNotRunning, OllamaModelNotAvailable) as e:
+        print(f"Error: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred: {e}")
+
+    # Initialize the model with your local server endpoint
+    model = OllamaLLM(
+        model="deepseek-r1:1.5b",
+    )
+
+    result = model.invoke("Come up with consise interesting fact")
+    server_mnger.cleanup()
+    print(result)