avrae-ls 0.4.1__py3-none-any.whl → 0.5.0__py3-none-any.whl

avrae_ls/context.py

@@ -1,229 +0,0 @@
-from __future__ import annotations
-
-import json
-import logging
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Any, Dict, Iterable
-
-import httpx
-
-from .config import AvraeLSConfig, ContextProfile, VarSources
-from .cvars import derive_character_cvars
-
-log = logging.getLogger(__name__)
-
-
-@dataclass
-class ContextData:
-    ctx: Dict[str, Any] = field(default_factory=dict)
-    combat: Dict[str, Any] = field(default_factory=dict)
-    character: Dict[str, Any] = field(default_factory=dict)
-    vars: VarSources = field(default_factory=VarSources)
-
-
-class ContextBuilder:
-    def __init__(self, config: AvraeLSConfig):
-        self._config = config
-        self._gvar_resolver = GVarResolver(config)
-
-    @property
-    def gvar_resolver(self) -> "GVarResolver":
-        return self._gvar_resolver
-
-    def build(self, profile_name: str | None = None) -> ContextData:
-        profile = self._select_profile(profile_name)
-        combat = self._ensure_me_combatant(profile)
-        merged_vars = self._merge_character_cvars(profile.character, self._load_var_files().merge(profile.vars))
-        self._gvar_resolver.seed(merged_vars.gvars)
-        return ContextData(
-            ctx=dict(profile.ctx),
-            combat=combat,
-            character=dict(profile.character),
-            vars=merged_vars,
-        )
-
-    def _select_profile(self, profile_name: str | None) -> ContextProfile:
-        if profile_name and profile_name in self._config.profiles:
-            return self._config.profiles[profile_name]
-        if self._config.default_profile in self._config.profiles:
-            return self._config.profiles[self._config.default_profile]
-        return next(iter(self._config.profiles.values()))
-
-    def _load_var_files(self) -> VarSources:
-        merged = VarSources()
-        for path in self._config.var_files:
-            data = _read_json_file(path)
-            if data is None:
-                continue
-            merged = merged.merge(VarSources.from_data(data))
-        return merged
-
-    def _merge_character_cvars(self, character: Dict[str, Any], vars: VarSources) -> VarSources:
-        merged = vars
-        char_cvars = character.get("cvars") or {}
-        if char_cvars:
-            merged = merged.merge(VarSources(cvars=dict(char_cvars)))
-
-        builtin_cvars = derive_character_cvars(character)
-        if builtin_cvars:
-            merged = merged.merge(VarSources(cvars=builtin_cvars))
-        return merged
-
-    def _ensure_me_combatant(self, profile: ContextProfile) -> Dict[str, Any]:
-        combat = dict(profile.combat or {})
-        combatants = list(combat.get("combatants") or [])
-        me = combat.get("me")
-        author_id = (profile.ctx.get("author") or {}).get("id")
-
-        def _matches_author(combatant: Dict[str, Any]) -> bool:
-            try:
-                return author_id is not None and str(combatant.get("controller")) == str(author_id)
-            except Exception:
-                return False
-
-        # Use an existing combatant controlled by the author if me is missing.
-        if me is None:
-            for existing in combatants:
-                if _matches_author(existing):
-                    me = existing
-                    break
-
-        # If still missing, synthesize a combatant from the character sheet.
-        if me is None and profile.character:
-            me = {
-                "name": profile.character.get("name", "Player"),
-                "id": "cmb_player",
-                "controller": author_id,
-                "group": None,
-                "race": profile.character.get("race"),
-                "monster_name": None,
-                "is_hidden": False,
-                "init": profile.character.get("stats", {}).get("dexterity", 10),
-                "initmod": 0,
-                "type": "combatant",
-                "note": "Mock combatant for preview",
-                "effects": [],
-                "stats": profile.character.get("stats") or {},
-                "levels": profile.character.get("levels") or profile.character.get("class_levels") or {},
-                "skills": profile.character.get("skills") or {},
-                "saves": profile.character.get("saves") or {},
-                "resistances": profile.character.get("resistances") or {},
-                "spellbook": profile.character.get("spellbook") or {},
-                "attacks": profile.character.get("attacks") or [],
-                "max_hp": profile.character.get("max_hp"),
-                "hp": profile.character.get("hp"),
-                "temp_hp": profile.character.get("temp_hp"),
-                "ac": profile.character.get("ac"),
-                "creature_type": profile.character.get("creature_type"),
-            }
-
-        if me is not None:
-            combat["me"] = me
-            if not any(c is me for c in combatants) and not any(_matches_author(c) for c in combatants):
-                combatants.insert(0, me)
-            combat["combatants"] = combatants
-            if "current" not in combat or combat.get("current") is None:
-                combat["current"] = me
-        else:
-            combat["combatants"] = combatants
-
-        return combat
-
-
-class GVarResolver:
-    def __init__(self, config: AvraeLSConfig):
-        self._config = config
-        self._cache: Dict[str, Any] = {}
-
-    def reset(self, gvars: Dict[str, Any] | None = None) -> None:
-        self._cache = {}
-        if gvars:
-            self._cache.update({str(k): v for k, v in gvars.items()})
-
-    def seed(self, gvars: Dict[str, Any] | None = None) -> None:
-        """Merge provided gvars into the cache without dropping fetched values."""
-        if not gvars:
-            return
-        for k, v in gvars.items():
-            self._cache[str(k)] = v
-
-    def get_local(self, key: str) -> Any:
-        return self._cache.get(str(key))
-
-    async def ensure(self, key: str) -> bool:
-        key = str(key)
-        if key in self._cache:
-            log.debug("GVAR ensure cache hit for %s", key)
-            return True
-        if not self._config.enable_gvar_fetch:
-            log.warning("GVAR fetch disabled; skipping %s", key)
-            return False
-        if not self._config.service.token:
-            log.debug("GVAR fetch skipped for %s: no token configured", key)
-            return False
-
-        base_url = self._config.service.base_url.rstrip("/")
-        url = f"{base_url}/customizations/gvars/{key}"
-        # Avrae service expects the JWT directly in Authorization (no Bearer prefix).
-        headers = {"Authorization": str(self._config.service.token)}
-        try:
-            log.debug("GVAR fetching %s from %s", key, url)
-            async with httpx.AsyncClient(timeout=5) as client:
-                resp = await client.get(url, headers=headers)
-        except Exception as exc:
-            log.error("GVAR fetch failed for %s: %s", key, exc)
-            return False
-
-        if resp.status_code != 200:
-            log.warning(
-                "GVAR fetch returned %s for %s (body: %s)",
-                resp.status_code,
-                key,
-                (resp.text or "").strip(),
-            )
-            return False
-
-        value: Any = None
-        try:
-            payload = resp.json()
-        except Exception:
-            payload = None
-
-        if isinstance(payload, dict) and "value" in payload:
-            value = payload["value"]
-
-        log.debug("GVAR fetch parsed value for %s (type=%s)", key, type(value).__name__)
-
-        if value is None:
-            log.error("GVAR %s payload missing value", key)
-            return False
-        self._cache[key] = value
-        return True
-
-    def snapshot(self) -> Dict[str, Any]:
-        return dict(self._cache)
-
-    async def refresh(self, seed: Dict[str, Any] | None = None, keys: Iterable[str] | None = None) -> Dict[str, Any]:
-        self.reset(seed)
-        if keys:
-            for key in keys:
-                await self.ensure(key)
-        return self.snapshot()
-
-
-def _read_json_file(path: Path) -> Dict[str, Any] | None:
-    try:
-        text = path.read_text()
-    except FileNotFoundError:
-        log.debug("Var file not found: %s", path)
-        return None
-    except OSError as exc:
-        log.warning("Failed to read var file %s: %s", path, exc)
-        return None
-
-    try:
-        return json.loads(text)
-    except json.JSONDecodeError as exc:
-        log.warning("Failed to parse var file %s: %s", path, exc)
-        return None

avrae_ls/cvars.py

@@ -1,115 +0,0 @@
-from __future__ import annotations
-
-import math
-from typing import Any, Dict, Mapping
-
-ABILITY_KEYS = ["strength", "dexterity", "constitution", "intelligence", "wisdom", "charisma"]
-SAVE_KEYS = {
-    "strength": "str",
-    "dexterity": "dex",
-    "constitution": "con",
-    "intelligence": "int",
-    "wisdom": "wis",
-    "charisma": "cha",
-}
-
-
-def derive_character_cvars(character: Mapping[str, Any]) -> Dict[str, Any]:
-    """Build the documented cvar table values from a character payload."""
-    stats = character.get("stats") or {}
-    saves = character.get("saves") or {}
-    levels = character.get("levels") or {}
-    spellbook = character.get("spellbook") or {}
-    csettings = character.get("csettings") or {}
-
-    cvars: dict[str, Any] = {}
-
-    for ability in ABILITY_KEYS:
-        score = _int_or_none(stats.get(ability))
-        save_val = _int_or_none(saves.get(SAVE_KEYS[ability]))
-
-        if score is not None:
-            cvars[ability] = score
-            cvars[f"{ability}Mod"] = math.floor((score - 10) / 2)
-        if save_val is not None:
-            cvars[f"{ability}Save"] = save_val
-
-    armor = _int_or_none(character.get("ac"))
-    if armor is not None:
-        cvars["armor"] = armor
-
-    description = character.get("description")
-    if description is not None:
-        cvars["description"] = description
-
-    image = character.get("image")
-    if image is not None:
-        cvars["image"] = image
-
-    name = character.get("name")
-    if name is not None:
-        cvars["name"] = name
-
-    max_hp = _int_or_none(character.get("max_hp"))
-    if max_hp is not None:
-        cvars["hp"] = max_hp
-
-    color = _color_hex(csettings.get("color"))
-    if color is not None:
-        cvars["color"] = color
-
-    prof = _int_or_none(stats.get("prof_bonus"))
-    if prof is not None:
-        cvars["proficiencyBonus"] = prof
-
-    spell_mod = _spell_mod(spellbook, prof)
-    if spell_mod is not None:
-        cvars["spell"] = spell_mod
-
-    total_level = _sum_ints(levels.values())
-    if total_level is not None:
-        cvars["level"] = total_level
-
-    for cls, lvl in levels.items():
-        lvl_int = _int_or_none(lvl)
-        if lvl_int is None:
-            continue
-        cvars[f"{str(cls).replace(' ', '')}Level"] = lvl_int
-
-    return cvars
-
-
-def _int_or_none(value: Any) -> int | None:
-    if isinstance(value, dict) and "value" in value:
-        value = value.get("value")
-    try:
-        return int(value)
-    except (TypeError, ValueError):
-        return None
-
-
-def _spell_mod(spellbook: Mapping[str, Any], prof_bonus: int | None) -> int | None:
-    if "spell_mod" in spellbook:
-        return _int_or_none(spellbook.get("spell_mod"))
-    if "sab" in spellbook and prof_bonus is not None:
-        sab = _int_or_none(spellbook.get("sab"))
-        if sab is not None:
-            return sab - prof_bonus
-    return None
-
-
-def _sum_ints(values: Any) -> int | None:
-    try:
-        total = sum(int(v) for v in values)
-    except Exception:
-        return None
-    return total
-
-
-def _color_hex(value: Any) -> str | None:
-    if value is None:
-        return None
-    try:
-        return hex(int(value))[2:]
-    except (TypeError, ValueError):
-        return None