@elizaos/python 2.0.0-alpha.10

package/elizaos/bootstrap/utils/xml.py

@@ -0,0 +1,69 @@
+"""XML parsing utilities for elizaOS."""
+
+from __future__ import annotations
+
+import re
+from typing import Any
+
+
+def parse_key_value_xml(xml: str) -> dict[str, Any] | None:
+    """Parse key-value pairs from XML tags."""
+    if not xml or not isinstance(xml, str):
+        return None
+
+    result: dict[str, Any] = {}
+
+    response_match = re.search(r"<response>(.*?)</response>", xml, re.DOTALL)
+    content = response_match.group(1) if response_match else xml
+
+    tag_pattern = re.compile(r"<(\w+)(?:\s[^>]*)?>([^<]*(?:<(?!/\1>)[^<]*)*)</\1>", re.DOTALL)
+
+    for match in tag_pattern.finditer(content):
+        tag_name = match.group(1)
+        tag_value = match.group(2).strip()
+
+        if "<" in tag_value and ">" in tag_value:
+            nested_result = parse_nested_tags(tag_value)
+            if nested_result:
+                result[tag_name] = nested_result
+            else:
+                result[tag_name] = tag_value
+        else:
+            result[tag_name] = tag_value
+
+    return result if result else None
+
+
+def parse_nested_tags(content: str) -> dict[str, Any] | list[Any] | None:
+    """Parse nested XML tags."""
+    result: dict[str, list[Any]] = {}
+
+    tag_pattern = re.compile(r"<(\w+)(?:\s[^>]*)?>([^<]*(?:<(?!/\1>)[^<]*)*)</\1>", re.DOTALL)
+
+    for match in tag_pattern.finditer(content):
+        tag_name = match.group(1)
+        tag_value = match.group(2).strip()
+
+        if tag_name not in result:
+            result[tag_name] = []
+
+        if "<" in tag_value and ">" in tag_value:
+            nested = parse_nested_tags(tag_value)
+            if nested:
+                result[tag_name].append(nested)
+            else:
+                result[tag_name].append(tag_value)
+        else:
+            result[tag_name].append(tag_value)
+
+    if not result:
+        return None
+
+    simplified: dict[str, Any] = {}
+    for key, values in result.items():
+        if len(values) == 1:
+            simplified[key] = values[0]
+        else:
+            simplified[key] = values
+
+    return simplified

package/elizaos/character.py

@@ -0,0 +1,149 @@
+from __future__ import annotations
+
+import json
+import os
+from pathlib import Path
+from typing import Any
+
+from google.protobuf.json_format import MessageToDict, ParseDict
+
+from elizaos.types.agent import Character
+
+
+class CharacterValidationError(Exception):
+    def __init__(self, message: str, errors: list[str] | None = None) -> None:
+        super().__init__(message)
+        self.errors = errors or []
+
+
+class CharacterLoadError(Exception):
+    def __init__(self, message: str, cause: Exception | None = None) -> None:
+        super().__init__(message)
+        self.cause = cause
+
+
+def parse_character(input_data: str | dict[str, Any] | Character) -> Character:
+    if isinstance(input_data, Character):
+        return input_data
+
+    if isinstance(input_data, str):
+        # Treat as file path
+        return load_character_from_file(input_data)
+
+    if isinstance(input_data, dict):
+        return validate_and_create_character(input_data)
+
+    raise CharacterValidationError("Invalid character input format")
+
+
+def load_character_from_file(path: str) -> Character:
+    try:
+        file_path = Path(path)
+        if not file_path.exists():
+            raise CharacterLoadError(f"Character file not found: {path}")
+
+        with open(file_path, encoding="utf-8") as f:
+            data = json.load(f)
+
+        return validate_and_create_character(data)
+    except json.JSONDecodeError as e:
+        raise CharacterLoadError(f"Invalid JSON in character file: {path}", cause=e) from e
+    except CharacterValidationError:
+        raise
+    except Exception as e:
+        raise CharacterLoadError(f"Failed to load character from {path}: {e}", cause=e) from e
+
+
+def validate_and_create_character(data: dict[str, Any]) -> Character:
+    try:
+        character = Character()
+        ParseDict(data, character)
+        return character
+    except Exception as e:
+        error_message = str(e)
+        raise CharacterValidationError(
+            f"Character validation failed: {error_message}",
+            errors=[error_message],
+        ) from e
+
+
+def validate_character_config(character: Character) -> dict[str, Any]:
+    try:
+        # Re-validate by converting to dict and back
+        ParseDict(MessageToDict(character, preserving_proto_field_name=False), Character())
+        return {
+            "isValid": True,
+            "errors": [],
+        }
+    except Exception as e:
+        errors = [str(e)]
+        return {
+            "isValid": False,
+            "errors": errors,
+        }
+
+
+def merge_character_defaults(char: dict[str, Any]) -> Character:
+    defaults: dict[str, Any] = {
+        "settings": {},
+        "plugins": [],
+        "bio": [],
+    }
+
+    merged = {**defaults, **char}
+    if not merged.get("name"):
+        merged["name"] = "Unnamed Character"
+
+    character = Character()
+    ParseDict(merged, character)
+    return character
+
+
+def build_character_plugins(env: dict[str, str | None] | None = None) -> list[str]:
+    if env is None:
+        env = dict(os.environ)
+
+    def get_env(key: str) -> str | None:
+        value = env.get(key)
+        if value:
+            return value.strip() if isinstance(value, str) else value
+        return None
+
+    plugins: list[str] = ["@elizaos/plugin-sql"]
+    if get_env("ANTHROPIC_API_KEY"):
+        plugins.append("@elizaos/plugin-anthropic")
+    if get_env("OPENROUTER_API_KEY"):
+        plugins.append("@elizaos/plugin-openrouter")
+
+    # Embedding-capable plugins
+    if get_env("OPENAI_API_KEY"):
+        plugins.append("@elizaos/plugin-openai")
+    if get_env("GOOGLE_GENERATIVE_AI_API_KEY"):
+        plugins.append("@elizaos/plugin-google-genai")
+    if get_env("DISCORD_API_TOKEN"):
+        plugins.append("@elizaos/plugin-discord")
+    if all(
+        get_env(key)
+        for key in [
+            "X_API_KEY",
+            "X_API_SECRET",
+            "X_ACCESS_TOKEN",
+            "X_ACCESS_TOKEN_SECRET",
+        ]
+    ):
+        plugins.append("@elizaos/plugin-x")
+    if get_env("TELEGRAM_BOT_TOKEN"):
+        plugins.append("@elizaos/plugin-telegram")
+    has_llm_provider = any(
+        get_env(key)
+        for key in [
+            "ANTHROPIC_API_KEY",
+            "OPENROUTER_API_KEY",
+            "OPENAI_API_KEY",
+            "GOOGLE_GENERATIVE_AI_API_KEY",
+        ]
+    )
+    if not has_llm_provider:
+        plugins.append("@elizaos/plugin-ollama")
+
+    return plugins

package/elizaos/logger.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import logging
+import os
+import sys
+from typing import Any
+
+import structlog
+
+_DEFAULT_REDACT_KEYS: frozenset[str] = frozenset(
+    {
+        "password",
+        "passwd",
+        "secret",
+        "token",
+        "apikey",
+        "api_key",
+        "apisecret",
+        "api_secret",
+        "authorization",
+        "auth",
+        "credential",
+        "credentials",
+        "privatekey",
+        "private_key",
+        "accesstoken",
+        "access_token",
+        "refreshtoken",
+        "refresh_token",
+        "cookie",
+        "session",
+        "jwt",
+        "bearer",
+    }
+)
+
+
+def _parse_bool(value: str | None, *, default: bool) -> bool:
+    if value is None:
+        return default
+    normalized = value.strip().lower()
+    if normalized in {"1", "true", "yes", "on"}:
+        return True
+    if normalized in {"0", "false", "no", "off"}:
+        return False
+    return default
+
+
+def _build_redact_keys() -> frozenset[str]:
+    extra = os.environ.get("ELIZA_LOG_REDACT_KEYS", "")
+    extra_keys = {k.strip().lower() for k in extra.split(",") if k.strip()}
+    return _DEFAULT_REDACT_KEYS.union(extra_keys)
+
+
+def _redact_value(value: object, *, redact_keys: frozenset[str]) -> object:
+    if isinstance(value, dict):
+        redacted: dict[object, object] = {}
+        for k, v in value.items():
+            if isinstance(k, str) and k.lower() in redact_keys:
+                redacted[k] = "[REDACTED]"
+            else:
+                redacted[k] = _redact_value(v, redact_keys=redact_keys)
+        return redacted
+    if isinstance(value, list):
+        return [_redact_value(v, redact_keys=redact_keys) for v in value]
+    return value
+
+
+def _redaction_processor(
+    _logger: logging.Logger, _method_name: str, event_dict: structlog.types.EventDict
+) -> structlog.types.EventDict:
+    enabled = _parse_bool(os.environ.get("ELIZA_LOG_REDACT"), default=True)
+    if not enabled:
+        return event_dict
+    redact_keys = _build_redact_keys()
+    return _redact_value(event_dict, redact_keys=redact_keys)  # type: ignore[return-value]
+
+
+def configure_structlog(log_level: str = "INFO") -> None:
+    json_mode = _parse_bool(os.environ.get("LOG_JSON_FORMAT"), default=False)
+    show_timestamps = _parse_bool(os.environ.get("LOG_TIMESTAMPS"), default=True)
+
+    logging.basicConfig(
+        format="%(message)s",
+        stream=sys.stdout,
+        level=getattr(logging, log_level.upper(), logging.INFO),
+    )
+
+    base_processors: list[structlog.types.Processor] = [
+        structlog.stdlib.filter_by_level,
+        structlog.stdlib.add_logger_name,
+        structlog.stdlib.add_log_level,
+        structlog.stdlib.PositionalArgumentsFormatter(),
+        _redaction_processor,
+    ]
+    if show_timestamps:
+        base_processors.append(structlog.processors.TimeStamper(fmt="iso"))
+    base_processors.extend(
+        [
+            structlog.processors.StackInfoRenderer(),
+            structlog.processors.format_exc_info,
+            structlog.processors.UnicodeDecoder(),
+        ]
+    )
+
+    structlog.configure(
+        processors=[
+            *base_processors,
+            structlog.processors.JSONRenderer()
+            if json_mode
+            else structlog.dev.ConsoleRenderer(colors=True),
+        ],
+        wrapper_class=structlog.stdlib.BoundLogger,
+        context_class=dict,
+        logger_factory=structlog.stdlib.LoggerFactory(),
+        cache_logger_on_first_use=True,
+    )
+
+
+class Logger:
+    def __init__(
+        self,
+        namespace: str | None = None,
+        level: str = "INFO",
+    ) -> None:
+        self._namespace = namespace or "elizaos"
+        self._level = level
+        self._logger = structlog.get_logger(self._namespace)
+
+    @property
+    def namespace(self) -> str:
+        return self._namespace
+
+    def _log(
+        self,
+        level: str,
+        message: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> None:
+        log_method = getattr(self._logger, level.lower(), self._logger.info)
+        if args:
+            log_method(message, *args, **kwargs)
+        else:
+            log_method(message, **kwargs)
+
+    def debug(self, message: str, *args: Any, **kwargs: Any) -> None:
+        self._log("debug", message, *args, **kwargs)
+
+    def info(self, message: str, *args: Any, **kwargs: Any) -> None:
+        self._log("info", message, *args, **kwargs)
+
+    def warn(self, message: str, *args: Any, **kwargs: Any) -> None:
+        self._log("warning", message, *args, **kwargs)
+
+    def warning(self, message: str, *args: Any, **kwargs: Any) -> None:
+        self._log("warning", message, *args, **kwargs)
+
+    def error(self, message: str, *args: Any, **kwargs: Any) -> None:
+        self._log("error", message, *args, **kwargs)
+
+    def exception(self, message: str, *args: Any, **kwargs: Any) -> None:
+        self._log("exception", message, *args, exc_info=True, **kwargs)
+
+    def bind(self, **kwargs: Any) -> Logger:
+        new_logger = Logger(namespace=self._namespace, level=self._level)
+        new_logger._logger = self._logger.bind(**kwargs)
+        return new_logger
+
+
+def create_logger(
+    namespace: str | None = None,
+    level: str = "INFO",
+) -> Logger:
+    return Logger(namespace=namespace, level=level)
+
+
+configure_structlog(log_level=os.environ.get("LOG_LEVEL", "INFO"))
+logger = create_logger()

package/elizaos/media/__init__.py

@@ -0,0 +1,45 @@
+"""
+Media utilities for Eliza.
+
+Provides MIME type detection, media parsing, format utilities, and hybrid search.
+"""
+
+from .mime import (
+    MediaKind,
+    detect_mime,
+    extension_for_mime,
+    get_file_extension,
+    image_mime_from_format,
+    is_audio_filename,
+    is_gif_media,
+    is_voice_compatible_audio,
+    media_kind_from_mime,
+)
+from .search import (
+    HybridKeywordResult,
+    HybridMergedResult,
+    HybridVectorResult,
+    bm25_rank_to_score,
+    build_fts_query,
+    merge_hybrid_results,
+)
+
+__all__ = [
+    # MIME utilities
+    "MediaKind",
+    "detect_mime",
+    "extension_for_mime",
+    "get_file_extension",
+    "image_mime_from_format",
+    "is_audio_filename",
+    "is_gif_media",
+    "is_voice_compatible_audio",
+    "media_kind_from_mime",
+    # Hybrid search utilities
+    "HybridKeywordResult",
+    "HybridMergedResult",
+    "HybridVectorResult",
+    "bm25_rank_to_score",
+    "build_fts_query",
+    "merge_hybrid_results",
+]