holmesgpt 0.11.5__py3-none-any.whl

holmes/utils/file_utils.py

@@ -0,0 +1,56 @@
+import json
+import os
+import logging
+import yaml  # type: ignore
+
+
+def write_json_file(json_output_file: str, json_ob_to_dump):
+    try:
+        dirname = os.path.dirname(json_output_file)
+        if dirname:
+            os.makedirs(dirname, exist_ok=True)
+        with open(json_output_file, "w", encoding="utf-8") as f:
+            json.dump(json_ob_to_dump, f, ensure_ascii=False, indent=4, default=str)
+    except Exception:
+        logging.exception("Failed to create the json file.")
+        return
+
+
+def load_yaml_file(
+    path: str, raise_error: bool = True, warn_not_found: bool = True
+) -> dict:
+    try:
+        with open(path, "r", encoding="utf-8") as file:
+            parsed_yaml = yaml.safe_load(file)
+    except yaml.YAMLError as err:
+        logging.warning(f"Error parsing YAML from {path}: {err}")
+        if raise_error:
+            raise err
+        return {}
+    except FileNotFoundError as err:
+        if warn_not_found:
+            logging.warning(f"file {path} was not found.")
+        if raise_error:
+            raise err
+        return {}
+    except Exception as err:
+        logging.warning(f"Failed to open file {path}: {err}")
+        if raise_error:
+            raise err
+        return {}
+
+    if not parsed_yaml:
+        message = f"No content found in file: {path}"
+        logging.warning(message)
+        if raise_error:
+            raise ValueError(message)
+        return {}
+
+    if not isinstance(parsed_yaml, dict):
+        message = f"Invalid format: YAML file {path} does not contain a dictionary at the root."
+        logging.warning(message)
+        if raise_error:
+            raise ValueError(message)
+        return {}
+
+    return parsed_yaml

holmes/utils/global_instructions.py

@@ -0,0 +1,20 @@
+from typing import List, Optional
+
+from pydantic import BaseModel
+
+
+class Instructions(BaseModel):
+    instructions: List[str] = []
+
+
+def add_global_instructions_to_user_prompt(
+    user_prompt: str, global_instructions: Optional[Instructions]
+) -> str:
+    if (
+        global_instructions
+        and global_instructions.instructions
+        and len(global_instructions.instructions[0]) > 0
+    ):
+        instructions = "\n\n".join(global_instructions.instructions)
+        user_prompt += f"\n\nGlobal Instructions (use if relevant): {instructions}\n"
+    return user_prompt

holmes/utils/holmes_status.py

@@ -0,0 +1,22 @@
+from holmes.core.supabase_dal import SupabaseDal
+from holmes.config import Config
+from holmes import get_version  # type: ignore
+import logging
+
+
+def update_holmes_status_in_db(dal: SupabaseDal, config: Config):
+    logging.info("Updating status of holmes")
+
+    if not config.cluster_name:
+        raise Exception(
+            "Cluster name is missing in the configuration. Please ensure 'CLUSTER_NAME' is defined in the environment variables, "
+            "or verify that a cluster name is provided in the Robusta configuration file."
+        )
+
+    dal.upsert_holmes_status(
+        {
+            "cluster_id": config.cluster_name,
+            "model": config.get_models_list(),
+            "version": get_version(),
+        }
+    )

holmes/utils/holmes_sync_toolsets.py

@@ -0,0 +1,80 @@
+import logging
+from datetime import datetime
+from typing import Any, List
+
+import yaml  # type: ignore
+
+from holmes.config import Config
+from holmes.core.supabase_dal import SupabaseDal
+from holmes.core.tools import Toolset, ToolsetDBModel
+from holmes.plugins.prompts import load_and_render_prompt
+
+
+def log_toolsets_statuses(toolsets: List[Toolset]):
+    enabled_toolsets = [
+        toolset.name for toolset in toolsets if toolset.status.value == "enabled"
+    ]
+    disabled_toolsets = [
+        toolset.name for toolset in toolsets if toolset.status.value != "enabled"
+    ]
+    logging.info(f"Enabled toolsets: {enabled_toolsets}")
+    logging.info(f"Disabled toolsets: {disabled_toolsets}")
+
+
+def holmes_sync_toolsets_status(dal: SupabaseDal, config: Config) -> None:
+    """
+    Method for synchronizing toolsets with the database:
+    1) Fetch all built-in toolsets from the holmes/plugins/toolsets directory
+    2) Load custom toolsets defined in /etc/holmes/config/custom_toolset.yaml
+    3) Override default toolsets with corresponding custom configurations
+       and add any new custom toolsets that are not part of the defaults
+    4) Run the check_prerequisites method for each toolset
+    5) Use sync_toolsets to upsert toolset's status and remove toolsets that are not loaded from configs or folder with default directory
+    """
+    tool_executor = config.create_tool_executor(dal)
+
+    if not config.cluster_name:
+        raise Exception(
+            "Cluster name is missing in the configuration. Please ensure 'CLUSTER_NAME' is defined in the environment variables, "
+            "or verify that a cluster name is provided in the Robusta configuration file."
+        )
+
+    db_toolsets = []
+    updated_at = datetime.now().isoformat()
+    for toolset in tool_executor.toolsets:
+        # hiding disabled experimental toolsets from the docs
+        if toolset.experimental and not toolset.enabled:
+            continue
+        if not toolset.installation_instructions:
+            instructions = render_default_installation_instructions_for_toolset(toolset)
+            toolset.installation_instructions = instructions
+        db_toolsets.append(
+            ToolsetDBModel(
+                **toolset.model_dump(exclude_none=True),
+                toolset_name=toolset.name,
+                cluster_id=config.cluster_name,
+                account_id=dal.account_id,
+                updated_at=updated_at,
+            ).model_dump()
+        )
+    dal.sync_toolsets(db_toolsets, config.cluster_name)
+    log_toolsets_statuses(tool_executor.toolsets)
+
+
+def render_default_installation_instructions_for_toolset(toolset: Toolset) -> str:
+    env_vars = toolset.get_environment_variables()
+    context: dict[str, Any] = {
+        "env_vars": env_vars if env_vars else [],
+        "toolset_name": toolset.name,
+        "is_default": toolset.is_default,
+        "enabled": toolset.enabled,
+    }
+
+    example_config = toolset.get_example_config()
+    if example_config:
+        context["example_config"] = yaml.dump(example_config)
+
+    installation_instructions = load_and_render_prompt(
+        "file://holmes/utils/default_toolset_installation_guide.jinja2", context
+    )
+    return installation_instructions

holmes/utils/markdown_utils.py

@@ -0,0 +1,55 @@
+# based on https://github.com/kostyachum/python-markdown-plain-text/blob/main/markdown_plain_text/extention.py
+# MIT licensed
+from markdown import Extension, Markdown  # type: ignore
+
+from xml.etree.ElementTree import ProcessingInstruction
+from xml.etree.ElementTree import Comment, ElementTree
+
+
+def _serialize_plain_text(write, elem):
+    tag = elem.tag
+    text = elem.text
+    if tag is Comment:
+        pass
+    elif tag is ProcessingInstruction:
+        pass
+    elif tag is None:
+        if text:
+            write(text)
+        for e in elem:
+            _serialize_plain_text(write, e)
+    else:
+        if text:
+            if tag.lower() not in ["script", "style"]:
+                write(text)
+        for e in elem:
+            _serialize_plain_text(write, e)
+
+    if elem.tail:
+        write(elem.tail)
+
+
+def _write_plain_text(root):
+    assert root is not None
+    data = []
+    write = data.append
+    _serialize_plain_text(write, root)
+    return "".join(data)
+
+
+def to_plain_text(element):
+    return _write_plain_text(ElementTree(element).getroot())
+
+
+class PlainTextExtension(Extension):
+    def extendMarkdown(self, md):
+        md.serializer = to_plain_text
+        md.stripTopLevelTags = False
+
+        # Extention register actually runs before the format is set and it ends up rewriting serializer that we have just changed
+        md.set_output_format = lambda x: x
+
+
+def markdown_to_plain_text(text):
+    md = Markdown(extensions=[PlainTextExtension()])
+    return md.convert(text)

holmes/utils/pydantic_utils.py

@@ -0,0 +1,54 @@
+import sys
+from pathlib import Path
+from typing import Annotated, Any, Dict, List, Optional, Tuple, Type, Union
+
+import typer
+from benedict import benedict  # type: ignore
+from pydantic import BaseModel, BeforeValidator, ConfigDict, ValidationError
+
+from holmes.plugins.prompts import load_prompt
+
+PromptField = Annotated[str, BeforeValidator(lambda v: load_prompt(v))]
+
+
+class RobustaBaseConfig(BaseModel):
+    model_config = ConfigDict(extra="forbid", validate_default=True)
+
+
+def loc_to_dot_sep(loc: Tuple[Union[str, int], ...]) -> str:
+    path = ""
+    for i, x in enumerate(loc):
+        if isinstance(x, str):
+            if i > 0:
+                path += "."
+            path += x
+        elif isinstance(x, int):
+            path += f"[{x}]"
+        else:
+            raise TypeError("Unexpected type")
+    return path
+
+
+def convert_errors(e: ValidationError) -> List[Dict[str, Any]]:
+    new_errors: List[Dict[str, Any]] = e.errors()  # type: ignore
+    for error in new_errors:
+        error["loc"] = loc_to_dot_sep(error["loc"])
+    return new_errors
+
+
+def load_model_from_file(
+    model: Type[BaseModel], file_path: Path, yaml_path: Optional[str] = None
+):
+    try:
+        contents = benedict(file_path, format="yaml")
+        if yaml_path is not None:
+            contents = contents[yaml_path]
+        return model.model_validate(contents)
+    except ValidationError as e:
+        print(e)
+        bad_fields = [e["loc"] for e in convert_errors(e)]
+        typer.secho(
+            f"Invalid config file at {file_path}. Check the fields {bad_fields}.\nSee detailed errors above.",
+            fg="red",
+        )
+        sys.exit()

holmes/utils/robusta.py

@@ -0,0 +1,10 @@
+from holmes.config import Config
+from holmes.core.supabase_dal import SupabaseDal
+from pydantic import SecretStr
+from holmes.common.env_vars import load_bool
+
+
+def load_robusta_api_key(dal: SupabaseDal, config: Config):
+    if load_bool("ROBUSTA_AI", False):
+        account_id, token = dal.get_ai_credentials()
+        config.api_key = SecretStr(f"{account_id} {token}")

holmes/utils/tags.py

@@ -0,0 +1,97 @@
+import logging
+from typing import Optional
+from typing_extensions import Dict, List
+import re
+import json
+from copy import deepcopy
+
+
+def stringify_tag(tag: Dict[str, str]) -> Optional[str]:
+    """
+    This serializes a dictionary into something more readable to the LLM.
+    Although I have not seen much difference in quality of output, in theory this can help the LLM
+    understand better how to link the tag values with the tools.
+
+    Here are some examples of formatting (more can be found in the test for this function):
+        - { "type": "node", "name": "my-node" }
+            -> "node my-node"
+        - { "type": "issue", "id": "issue-id", "name": "KubeJobFailed", "subject_namespace": "my-namespace", "subject_name": "my-pod" }
+            -> issue issue-id (name=KubeJobFailed, subject_namespace=my-namespace, subject_name=my-pod)
+    """
+    type = tag.pop("type")
+    if not type:
+        return None
+
+    key = ""
+    if tag.get("id"):
+        key = tag.pop("id")
+    elif tag.get("name"):
+        key = tag.pop("name")
+
+    if not key:
+        return None
+
+    formatted_string = f"{type} {key}"
+
+    if len(tag) > 0:
+        keyVals = []
+        for k, v in tag.items():
+            keyVals.append(f"{k}={v}")
+        formatted_string += f" ({', '.join(keyVals)})"
+
+    return formatted_string
+
+
+def format_tags_in_string(user_prompt: str) -> str:
+    """
+    Formats the tags included in a user's message.
+    E.g.
+        'how many pods are running on << { "type": "node", "name": "my-node" } >>?'
+            -> 'how many pods are running on node my-node?'
+    """
+    try:
+        pattern = r"<<(.*?)>>"
+
+        def replace_match(match):
+            try:
+                json_str = match.group(1)
+                json_obj = json.loads(json_str)
+                formatted = stringify_tag(json_obj)
+                return formatted if formatted else match.group(0)
+            except (json.JSONDecodeError, AttributeError):
+                logging.warning(f"Failed to parse tag in string: {user_prompt}")
+                return match.group(0)
+
+        return re.sub(pattern, replace_match, user_prompt)
+    except Exception:
+        logging.warning(f"Failed to parse string: {user_prompt}")
+        return user_prompt
+
+
+def parse_messages_tags(messages: List[Dict[str, str]]) -> List[Dict[str, str]]:
+    """
+    Parses the user messages for tags and format these.
+    System messages and llm responses are ignored and left as-is
+
+    This method returns a shallow copy of the messages list with the exception
+    of the messages that have been parsed.
+    """
+    formatted_messages = []
+    for message in messages:
+        original_message = message.get("content")
+        if message.get("role") == "user" and original_message:
+            formatted_str = format_tags_in_string(original_message)
+            if formatted_str != message.get("content"):
+                formatted_message = deepcopy(message)
+                formatted_message["content"] = formatted_str
+                formatted_messages.append(formatted_message)
+                logging.debug(
+                    f"Message with tags '{original_message}' formatted to '{formatted_message}'"
+                )
+            else:
+                formatted_messages.append(message)
+
+        else:
+            formatted_messages.append(message)
+
+    return formatted_messages

holmesgpt-0.11.5.dist-info/LICENSE.txt

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Robusta Dev Ltd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.