logdetective 0.2.12__tar.gz → 0.2.14__tar.gz

{logdetective-0.2.12 → logdetective-0.2.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: logdetective
-Version: 0.2.12
+Version: 0.2.14
 Summary: Log using LLM AI to search for build/test failures and provide ideas for fixing these.
 License: Apache-2.0
 Author: Jiri Podivin
@@ -18,7 +18,6 @@ Classifier: Programming Language :: Python :: 3.13
 Classifier: Topic :: Internet :: Log Analysis
 Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
 Classifier: Topic :: Software Development :: Debuggers
-Provides-Extra: server
 Requires-Dist: drain3 (>=0.9.11,<0.10.0)
 Requires-Dist: huggingface-hub (>0.23.2)
 Requires-Dist: llama-cpp-python (>0.2.56,!=0.2.86)

logdetective-0.2.14/logdetective/server/models.py

@@ -0,0 +1,82 @@
+from typing import List, Dict, Optional
+from pydantic import BaseModel
+
+
+class BuildLog(BaseModel):
+    """Model of data submitted to API."""
+
+    url: str
+
+
+class Response(BaseModel):
+    """Model of data returned by Log Detective API
+
+    explanation: CreateCompletionResponse
+        https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.llama_types.CreateCompletionResponse
+    response_certainty: float
+    """
+
+    explanation: Dict
+    response_certainty: float
+
+
+class StagedResponse(Response):
+    """Model of data returned by Log Detective API when called when staged response
+    is requested. Contains list of reponses to prompts for individual snippets.
+
+    explanation: CreateCompletionResponse
+        https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.llama_types.CreateCompletionResponse
+    response_certainty: float
+    snippets:
+        list of dictionaries { 'snippet' : '<original_text>, 'comment': CreateCompletionResponse }
+    """
+
+    snippets: List[Dict[str, str | Dict]]
+
+
+class InferenceConfig(BaseModel):
+    """Model for inference configuration of logdetective server."""
+
+    max_tokens: int = -1
+    log_probs: int = 1
+
+    def __init__(self, data: Optional[dict] = None):
+        super().__init__()
+        if data is None:
+            return
+
+        self.max_tokens = data.get("max_tokens", -1)
+        self.log_probs = data.get("log_probs", 1)
+
+
+class ExtractorConfig(BaseModel):
+    """Model for extractor configuration of logdetective server."""
+
+    context: bool = True
+    max_clusters: int = 8
+    verbose: bool = False
+
+    def __init__(self, data: Optional[dict] = None):
+        super().__init__()
+        if data is None:
+            return
+
+        self.context = data.get("context", True)
+        self.max_clusters = data.get("max_clusters", 8)
+        self.verbose = data.get("verbose", False)
+
+
+class Config(BaseModel):
+    """Model for configuration of logdetective server."""
+
+    inference: InferenceConfig = InferenceConfig()
+    extractor: ExtractorConfig = ExtractorConfig()
+
+    def __init__(self, data: Optional[dict] = None):
+        super().__init__()
+
+        if data is None:
+            return
+
+        self.inference = InferenceConfig(data.get("inference"))
+        self.extractor = ExtractorConfig(data.get("extractor"))

{logdetective-0.2.12/logdetective → logdetective-0.2.14/logdetective/server}/server.py

@@ -2,50 +2,23 @@ import asyncio
 import json
 import logging
 import os
-from typing import List, Annotated, Dict
+from typing import List, Annotated
 
 from llama_cpp import CreateCompletionResponse
 from fastapi import FastAPI, HTTPException, Depends, Header
 from fastapi.responses import StreamingResponse
-from pydantic import BaseModel
 import requests
 
 from logdetective.constants import (
-    PROMPT_TEMPLATE, SNIPPET_PROMPT_TEMPLATE,
-    PROMPT_TEMPLATE_STAGED, SNIPPET_DELIMITER)
+    PROMPT_TEMPLATE,
+    SNIPPET_PROMPT_TEMPLATE,
+    PROMPT_TEMPLATE_STAGED,
+    SNIPPET_DELIMITER,
+)
 from logdetective.extractors import DrainExtractor
 from logdetective.utils import validate_url, compute_certainty
-
-
-class BuildLog(BaseModel):
-    """Model of data submitted to API.
-    """
-    url: str
-
-
-class Response(BaseModel):
-    """Model of data returned by Log Detective API
-
-    explanation: CreateCompletionResponse
-        https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.llama_types.CreateCompletionResponse
-    response_certainty: float
-    """
-    explanation: Dict
-    response_certainty: float
-
-
-class StagedResponse(Response):
-    """Model of data returned by Log Detective API when called when staged response
-    is requested. Contains list of reponses to prompts for individual snippets.
-
-    explanation: CreateCompletionResponse
-        https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.llama_types.CreateCompletionResponse
-    response_certainty: float
-    snippets:
-        list of dictionaries { 'snippet' : '<original_text>, 'comment': CreateCompletionResponse }
-    """
-    snippets: List[Dict[str, str | Dict]]
-
+from logdetective.server.models import BuildLog, Response, StagedResponse
+from logdetective.server.utils import load_server_config
 
 LOG = logging.getLogger("logdetective")
 
@@ -55,6 +28,10 @@ LLM_CPP_SERVER_PORT = os.environ.get("LLAMA_CPP_SERVER_PORT", 8000)
 LLM_CPP_SERVER_TIMEOUT = os.environ.get("LLAMA_CPP_SERVER_TIMEOUT", 600)
 LOG_SOURCE_REQUEST_TIMEOUT = os.environ.get("LOG_SOURCE_REQUEST_TIMEOUT", 60)
 API_TOKEN = os.environ.get("LOGDETECTIVE_TOKEN", None)
+SERVER_CONFIG_PATH = os.environ.get("LOGDETECTIVE_SERVER_CONF", None)
+LLM_API_TOKEN = os.environ.get("LLM_API_TOKEN", None)
+
+SERVER_CONFIG = load_server_config(SERVER_CONFIG_PATH)
 
 
 def requires_token_when_set(authentication: Annotated[str | None, Header()] = None):
@@ -75,13 +52,15 @@ def requires_token_when_set(authentication: Annotated[str | None, Header()] = No
         except (ValueError, IndexError):
             LOG.warning(
                 "Authentication header has invalid structure (%s), it should be 'Bearer TOKEN'",
-                authentication)
+                authentication,
+            )
             # eat the exception and raise 401 below
             token = None
         if token == API_TOKEN:
             return
-    LOG.info("LOGDETECTIVE_TOKEN env var is set (%s), clien token = %s",
-             API_TOKEN, token)
+    LOG.info(
+        "LOGDETECTIVE_TOKEN env var is set (%s), clien token = %s", API_TOKEN, token
+    )
     raise HTTPException(status_code=401, detail=f"Token {token} not valid.")
 
 
@@ -89,45 +68,51 @@ app = FastAPI(dependencies=[Depends(requires_token_when_set)])
 
 
 def process_url(url: str) -> str:
-    """Validate log URL and return log text.
-    """
+    """Validate log URL and return log text."""
     if validate_url(url=url):
         try:
             log_request = requests.get(url, timeout=int(LOG_SOURCE_REQUEST_TIMEOUT))
         except requests.RequestException as ex:
             raise HTTPException(
-                status_code=400,
-                detail=f"We couldn't obtain the logs: {ex}") from ex
+                status_code=400, detail=f"We couldn't obtain the logs: {ex}"
+            ) from ex
 
         if not log_request.ok:
-            raise HTTPException(status_code=400,
-                                detail="Something went wrong while getting the logs: "
-                                f"[{log_request.status_code}] {log_request.text}")
+            raise HTTPException(
+                status_code=400,
+                detail="Something went wrong while getting the logs: "
+                f"[{log_request.status_code}] {log_request.text}",
+            )
     else:
         LOG.error("Invalid URL received ")
-        raise HTTPException(status_code=400,
-                            detail=f"Invalid log URL: {url}")
+        raise HTTPException(status_code=400, detail=f"Invalid log URL: {url}")
 
     return log_request.text
 
 
 def mine_logs(log: str) -> List[str]:
-    """Extract snippets from log text
-    """
-    extractor = DrainExtractor(verbose=True, context=True, max_clusters=16)
+    """Extract snippets from log text"""
+    extractor = DrainExtractor(
+        verbose=True, context=True, max_clusters=SERVER_CONFIG.extractor.max_clusters
+    )
 
     LOG.info("Getting summary")
     log_summary = extractor(log)
 
-    ratio = len(log_summary) / len(log.split('\n'))
+    ratio = len(log_summary) / len(log.split("\n"))
     LOG.debug("Log summary: \n %s", log_summary)
     LOG.info("Compression ratio: %s", ratio)
 
     return log_summary
 
 
-async def submit_text(text: str, max_tokens: int = -1, log_probs: int = 1, stream: bool = False,
-                      model: str = "default-model"):
+async def submit_text(
+    text: str,
+    max_tokens: int = -1,
+    log_probs: int = 1,
+    stream: bool = False,
+    model: str = "default-model",
+):
     """Submit prompt to LLM.
     max_tokens: number of tokens to be produces, 0 indicates run until encountering EOS
     log_probs: number of token choices to produce log probs for
@@ -138,33 +123,42 @@ async def submit_text(text: str, max_tokens: int = -1, log_probs: int = 1, strea
         "max_tokens": max_tokens,
         "logprobs": log_probs,
         "stream": stream,
-        "model": model}
+        "model": model,
+    }
+
+    headers = {"Content-Type": "application/json"}
+
+    if LLM_API_TOKEN:
+        headers["Authorization"] = f"Bearer {LLM_API_TOKEN}"
 
     try:
         # Expects llama-cpp server to run on LLM_CPP_SERVER_ADDRESS:LLM_CPP_SERVER_PORT
         response = requests.post(
             f"{LLM_CPP_SERVER_ADDRESS}:{LLM_CPP_SERVER_PORT}/v1/completions",
-            headers={"Content-Type": "application/json"},
+            headers=headers,
             data=json.dumps(data),
             timeout=int(LLM_CPP_SERVER_TIMEOUT),
-            stream=stream)
+            stream=stream,
+        )
     except requests.RequestException as ex:
         raise HTTPException(
-            status_code=400,
-            detail=f"Llama-cpp query failed: {ex}") from ex
+            status_code=400, detail=f"Llama-cpp query failed: {ex}"
+        ) from ex
     if not stream:
         if not response.ok:
             raise HTTPException(
                 status_code=400,
                 detail="Something went wrong while getting a response from the llama server: "
-                       f"[{response.status_code}] {response.text}")
+                f"[{response.status_code}] {response.text}",
+            )
         try:
             response = json.loads(response.text)
         except UnicodeDecodeError as ex:
             LOG.error("Error encountered while parsing llama server response: %s", ex)
             raise HTTPException(
                 status_code=400,
-                detail=f"Couldn't parse the response.\nError: {ex}\nData: {response.text}") from ex
+                detail=f"Couldn't parse the response.\nError: {ex}\nData: {response.text}",
+            ) from ex
     else:
         return response
 
@@ -187,13 +181,15 @@ async def analyze_log(build_log: BuildLog):
     if "logprobs" in response["choices"][0]:
         try:
             certainty = compute_certainty(
-                response["choices"][0]["logprobs"]["content"][0]["top_logprobs"])
+                response["choices"][0]["logprobs"]["content"][0]["top_logprobs"]
+            )
         except ValueError as ex:
             LOG.error("Error encountered while computing certainty: %s", ex)
             raise HTTPException(
                 status_code=400,
                 detail=f"Couldn't compute certainty with data:\n"
-                f"{response["choices"][0]["logprobs"]["content"][0]["top_logprobs"]}") from ex
+                f"{response["choices"][0]["logprobs"]["content"][0]["top_logprobs"]}",
+            ) from ex
 
     return Response(explanation=response, response_certainty=certainty)
 
@@ -211,15 +207,21 @@ async def analyze_log_staged(build_log: BuildLog):
 
     # Process snippets asynchronously
     analyzed_snippets = await asyncio.gather(
-        *[submit_text(SNIPPET_PROMPT_TEMPLATE.format(s)) for s in log_summary])
+        *[submit_text(SNIPPET_PROMPT_TEMPLATE.format(s)) for s in log_summary]
+    )
 
     analyzed_snippets = [
-        {"snippet": e[0], "comment": e[1]} for e in zip(log_summary, analyzed_snippets)]
+        {"snippet": e[0], "comment": e[1]} for e in zip(log_summary, analyzed_snippets)
+    ]
 
     final_prompt = PROMPT_TEMPLATE_STAGED.format(
-        f"\n{SNIPPET_DELIMITER}\n".join([
-            f"[{e["snippet"]}] : [{e["comment"]["choices"][0]["text"]}]"
-            for e in analyzed_snippets]))
+        f"\n{SNIPPET_DELIMITER}\n".join(
+            [
+                f"[{e["snippet"]}] : [{e["comment"]["choices"][0]["text"]}]"
+                for e in analyzed_snippets
+            ]
+        )
+    )
 
     final_analysis = await submit_text(final_prompt)
     print(final_analysis)
@@ -228,16 +230,21 @@ async def analyze_log_staged(build_log: BuildLog):
     if "logprobs" in final_analysis["choices"][0]:
         try:
             certainty = compute_certainty(
-                final_analysis["choices"][0]["logprobs"]["content"][0]["top_logprobs"])
+                final_analysis["choices"][0]["logprobs"]["content"][0]["top_logprobs"]
+            )
         except ValueError as ex:
             LOG.error("Error encountered while computing certainty: %s", ex)
             raise HTTPException(
                 status_code=400,
                 detail=f"Couldn't compute certainty with data:\n"
-                f"{final_analysis["choices"][0]["logprobs"]["content"][0]["top_logprobs"]}") from ex
+                f"{final_analysis["choices"][0]["logprobs"]["content"][0]["top_logprobs"]}",
+            ) from ex
 
     return StagedResponse(
-        explanation=final_analysis, snippets=analyzed_snippets, response_certainty=certainty)
+        explanation=final_analysis,
+        snippets=analyzed_snippets,
+        response_certainty=certainty,
+    )
 
 
 @app.post("/analyze/stream", response_class=StreamingResponse)

logdetective-0.2.14/logdetective/server/utils.py

@@ -0,0 +1,15 @@
+import yaml
+from logdetective.server.models import Config
+
+
+def load_server_config(path: str | None) -> Config:
+    """Load configuration file for logdetective server.
+    If no path was provided, or if the file doesn't exist, return defaults.
+    """
+    if path is not None:
+        try:
+            with open(path, "r") as config_file:
+                return Config(yaml.safe_load(config_file))
+        except FileNotFoundError:
+            pass
+    return Config()

{logdetective-0.2.12 → logdetective-0.2.14}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "logdetective"
-version = "0.2.12"
+version = "0.2.14"
 description = "Log using LLM AI to search for build/test failures and provide ideas for fixing these."
 authors = ["Jiri Podivin <jpodivin@gmail.com>"]
 license = "Apache-2.0"
@@ -35,6 +35,11 @@ huggingface-hub = ">0.23.2"
 # we need to support both versions
 numpy = ">=1.26.0"
 
+[tool.poetry.group.server.dependencies]
+fastapi = "^0.115.8"
+pydantic = "^2.10.6"
+pyyaml = "^6.0.2"
+
 [build-system]
 requires = ["poetry-core"]
 build-backend = "poetry.core.masonry.api"
@@ -42,9 +47,6 @@ build-backend = "poetry.core.masonry.api"
 [tool.poetry.scripts]
 logdetective = 'logdetective.logdetective:main'
 
-[tool.poetry.extras]
-server = ["fastapi", "pydantic"]
-
 [tool.pylint]
 disable = [
     "inconsistent-return-statements",