avrae-ls 0.2.1__py3-none-any.whl → 0.3.1__py3-none-any.whl

avrae_ls/context.py

@@ -93,31 +93,49 @@ class GVarResolver:
     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}/gvars/{key}"
-        headers = {"Authorization": f"Bearer {self._config.service.token}"}
+        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.debug("GVAR fetch failed for %s: %s", key, exc)
+            log.error("GVAR fetch failed for %s: %s", key, exc)
             return False
 
         if resp.status_code != 200:
-            log.debug("GVAR fetch returned %s for %s", resp.status_code, key)
+            log.warning(
+                "GVAR fetch returned %s for %s (body: %s)",
+                resp.status_code,
+                key,
+                (resp.text or "").strip(),
+            )
             return False
 
-        payload = resp.json()
-        value = payload.get("value") or payload.get("content") or payload.get("body")
+        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.debug("GVAR %s payload missing value", key)
+            log.error("GVAR %s payload missing value", key)
             return False
         self._cache[key] = value
         return True

avrae_ls/diagnostics.py

@@ -149,6 +149,13 @@ class DiagnosticProvider:
                         )
                     )
 
+            def visit_Call(self, node: ast.Call):
+                if isinstance(node.func, ast.Name) and node.func.id == "using":
+                    for kw in node.keywords:
+                        if kw.arg:
+                            self.tracker.add(str(kw.arg))
+                self.generic_visit(node)
+
         walker = Walker(known)
         for stmt in body:
             walker.visit(stmt)
@@ -200,24 +207,41 @@ async def _check_gvars(
     settings: DiagnosticSettings,
 ) -> List[types.Diagnostic]:
     diagnostics: list[types.Diagnostic] = []
+    seen: set[str] = set()
+
+    def _literal_value(node: ast.AST) -> str | None:
+        if isinstance(node, ast.Constant) and isinstance(node.value, str):
+            return node.value
+        if isinstance(node, ast.Str):
+            return node.s
+        return None
+
     for node in _iter_calls(body):
-        if not isinstance(node.func, ast.Name) or node.func.id != "get_gvar":
+        if not isinstance(node.func, ast.Name):
             continue
-        if not node.args:
-            continue
-        arg = node.args[0]
-        if isinstance(arg, (ast.Str, ast.Constant)) and isinstance(getattr(arg, "s", None) or arg.value, str):
-            gvar_id = arg.s if isinstance(arg, ast.Str) else arg.value
+
+        async def _validate_gvar(arg_node: ast.AST):
+            gvar_id = _literal_value(arg_node)
+            if gvar_id is None or gvar_id in seen:
+                return
+            seen.add(gvar_id)
             found_local = resolver.get_local(gvar_id)
             ensured = found_local is not None or await resolver.ensure(gvar_id)
             if not ensured:
                 diagnostics.append(
                     _make_diagnostic(
-                        arg,
+                        arg_node,
                         f"Unknown gvar '{gvar_id}'",
                         settings.semantic_level,
                     )
                 )
+
+        if node.func.id == "get_gvar":
+            if node.args:
+                await _validate_gvar(node.args[0])
+        elif node.func.id == "using":
+            for kw in node.keywords:
+                await _validate_gvar(kw.value)
     return diagnostics
 
 
@@ -342,7 +366,7 @@ def _build_builtin_signatures() -> dict[str, inspect.Signature]:
     def get(name, default=None): ...
     def using(**imports): ...
     def signature(data=0): ...
-    def verify_signature(sig=None): ...
+    def verify_signature(data): ...
     def print_fn(*args, sep=" ", end="\n"): ...
 
     helpers = {

avrae_ls/runtime.py

@@ -1,12 +1,13 @@
 from __future__ import annotations
 
-import io
-import logging
-import time
 import ast
+import io
 import json
-import random
+import logging
 import math
+import random
+import time
+from types import SimpleNamespace
 try:  # optional dependency
     import yaml
 except ImportError:  # pragma: no cover - fallback when PyYAML is absent
@@ -16,10 +17,11 @@ from typing import Any, Dict, Set, Callable
 
 import d20
 import draconic
+import httpx
 from draconic.interpreter import _Break, _Continue, _Return
 
 from .context import ContextData, GVarResolver
-from .config import VarSources
+from .config import AvraeServiceConfig, VarSources
 from .api import AliasContextAPI, CharacterAPI, SimpleCombat, SimpleRollResult
 from . import argparser as avrae_argparser
 # Minimal stand-in for Avrae's AliasException
@@ -127,12 +129,9 @@ def _default_builtins() -> Dict[str, Any]:
         "abs": abs,
         "range": range,
         "enumerate": enumerate,
-        "sorted": sorted,
-        "reversed": reversed,
         "int": int,
         "float": float,
         "str": str,
-        "bool": bool,
         "round": round,
         "ceil": math.ceil,
         "floor": math.floor,
@@ -156,8 +155,9 @@ def _default_builtins() -> Dict[str, Any]:
 
 
 class MockExecutor:
-    def __init__(self):
+    def __init__(self, service_config: AvraeServiceConfig | None = None):
         self._base_builtins = _default_builtins()
+        self._service_config = service_config or AvraeServiceConfig()
 
     def available_names(self, ctx_data: ContextData) -> Set[str]:
         builtin_names = set(self._base_builtins.keys())
@@ -220,12 +220,16 @@ class MockExecutor:
                 runtime_character = CharacterAPI(ctx_data.character)
             return runtime_character  # type: ignore[return-value]
 
+        import_cache: dict[str, SimpleNamespace] = {}
+        import_stack: list[str] = []
         builtins = self._build_builtins(
             ctx_data,
             resolver,
             buffer,
             character_provider=_character_provider,
             interpreter_ref=interpreter_ref,
+            import_cache=import_cache,
+            import_stack=import_stack,
         )
         interpreter = draconic.DraconicInterpreter(
             builtins=builtins,
@@ -266,10 +270,18 @@ class MockExecutor:
         buffer: io.StringIO,
         character_provider: Callable[[], CharacterAPI] | None = None,
         interpreter_ref: Dict[str, draconic.DraconicInterpreter | None] | None = None,
+        import_cache: Dict[str, SimpleNamespace] | None = None,
+        import_stack: list[str] | None = None,
     ) -> Dict[str, Any]:
         builtins = dict(self._base_builtins)
         var_store = ctx_data.vars
         interpreter_ref = interpreter_ref or {"interpreter": None}
+        import_cache = import_cache or {}
+        import_stack = import_stack or []
+        service_cfg = self._service_config
+        verify_cache_sig: str | None = None
+        verify_cache_result: Dict[str, Any] | None = None
+        verify_cache_error: ValueError | None = None
 
         def _print(*args, sep=" ", end="\n"):
             buffer.write(sep.join(map(str, args)) + end)
@@ -283,22 +295,25 @@ class MockExecutor:
             return var_store.svars.get(str(name), default)
 
         def _get_cvar(name: str, default=None):
-            return var_store.cvars.get(str(name), default)
+            val = var_store.cvars.get(str(name), default)
+            return str(val) if val is not None else default
 
         def _get_uvar(name: str, default=None):
-            return var_store.uvars.get(str(name), default)
+            val = var_store.uvars.get(str(name), default)
+            return str(val) if val is not None else default
 
         def _get_uvars():
-            return dict(var_store.uvars)
+            return {k: (str(v) if v is not None else v) for k, v in var_store.uvars.items()}
 
         def _set_uvar(name: str, value: Any):
-            var_store.uvars[str(name)] = value
-            return value
+            str_val = str(value) if value is not None else None
+            var_store.uvars[str(name)] = str_val
+            return str_val
 
         def _set_uvar_nx(name: str, value: Any):
             key = str(name)
             if key not in var_store.uvars:
-                var_store.uvars[key] = value
+                var_store.uvars[key] = str(value) if value is not None else None
             return var_store.uvars[key]
 
         def _delete_uvar(name: str):
@@ -307,37 +322,136 @@ class MockExecutor:
         def _uvar_exists(name: str) -> bool:
             return str(name) in var_store.uvars
 
-        def _exists(name: str) -> bool:
+        def _resolve_name(key: str) -> tuple[bool, Any]:
+            key = str(key)
             interp = interpreter_ref.get("interpreter")
-            if interp is None:
-                return False
-            return str(name) in getattr(interp, "_names", {})
+            if interp is not None:
+                names = getattr(interp, "_names", {})
+                if key in names:
+                    return True, names[key]
+
+            if key in var_store.cvars:
+                return True, var_store.cvars[key]
+
+            if key in var_store.uvars:
+                return True, var_store.uvars[key]
+
+            return False, None
+
+        def _exists(name: str) -> bool:
+            found, _ = _resolve_name(name)
+            return found
 
         def _get(name: str, default=None):
-            interp = interpreter_ref.get("interpreter")
-            if interp is None:
-                return default
-            return getattr(interp, "_names", {}).get(str(name), default)
+            found, value = _resolve_name(name)
+            return value if found else default
 
         def _using(**imports):
             interp = interpreter_ref.get("interpreter")
             if interp is None:
                 return None
+            user_ns = getattr(interp, "_names", {})
+
+            def _load_module(addr: str) -> SimpleNamespace:
+                if addr in import_cache:
+                    return import_cache[addr]
+                if resolver is None:
+                    raise ModuleNotFoundError(f"No gvar named {addr!r}")
+                mod_contents = resolver.get_local(addr)
+                if mod_contents is None:
+                    raise ModuleNotFoundError(f"No gvar named {addr!r}")
+
+                old_names = getattr(interp, "_names", {})
+                depth_increased = False
+                try:
+                    interp._names = {}
+                    interp._depth += 1
+                    depth_increased = True
+                    if interp._depth > interp._config.max_recursion_depth:
+                        raise RecursionError("Maximum recursion depth exceeded")
+                    interp.execute_module(str(mod_contents), module_name=addr)
+                    mod_ns = SimpleNamespace(**getattr(interp, "_names", {}))
+                    import_cache[addr] = mod_ns
+                    return mod_ns
+                finally:
+                    if depth_increased:
+                        interp._depth -= 1
+                    interp._names = old_names
+
             for ns, addr in imports.items():
-                val = None
-                if resolver:
-                    val = resolver.get_local(addr)
-                interp._names[str(ns)] = val  # type: ignore[attr-defined]
+                addr_str = str(addr)
+                if addr_str in import_stack:
+                    circle = " imports\n".join(import_stack)
+                    raise ImportError(f"Circular import detected!\n{circle} imports\n{addr_str}")
+                import_stack.append(addr_str)
+                try:
+                    mod_ns = _load_module(addr_str)
+                finally:
+                    import_stack.pop()
+                name = str(ns)
+                if name in interp.builtins:
+                    raise ValueError(f"{name} is already builtin (no shadow assignments).")
+                user_ns[name] = mod_ns
+
+            interp._names = user_ns
             return None
 
         def _signature(data=0):
-            return f"signature:{int(data)}"
+            try:
+                data = int(data)
+            except ValueError:
+                raise TypeError(f"Data {data} could not be converted to integer.")
+            return f"mock-signature:{int(data)}"
 
         def _verify_signature(sig):
+            nonlocal verify_cache_sig, verify_cache_result, verify_cache_error
+            sig_str = str(sig)
+            if sig_str == verify_cache_sig:
+                if verify_cache_error:
+                    raise verify_cache_error
+                return verify_cache_result
+
+            verify_cache_sig = sig_str
+            verify_cache_error = None
+            verify_cache_result = None
+
+            def _call_verify_api(signature: str) -> Dict[str, Any]:
+                base_url = (service_cfg.base_url if service_cfg else AvraeServiceConfig.base_url).rstrip("/")
+                url = f"{base_url}/bot/signature/verify"
+                headers = {"Content-Type": "application/json"}
+                if service_cfg and service_cfg.token:
+                    headers["Authorization"] = str(service_cfg.token)
+                try:
+                    resp = httpx.post(url, json={"signature": signature}, headers=headers, timeout=5)
+                except Exception as exc:
+                    raise ValueError(f"Failed to verify signature: {exc}") from exc
+
+                try:
+                    payload = resp.json()
+                except Exception as exc:
+                    raise ValueError("Failed to verify signature: invalid response body") from exc
+
+                if resp.status_code != 200:
+                    message = payload.get("error") if isinstance(payload, dict) else None
+                    raise ValueError(message or f"Failed to verify signature: HTTP {resp.status_code}")
+
+                if not isinstance(payload, dict):
+                    raise ValueError("Failed to verify signature: invalid response")
+                if payload.get("success") is not True:
+                    message = payload.get("error")
+                    raise ValueError(message or "Failed to verify signature: unsuccessful response")
+
+                data = payload.get("data")
+                if not isinstance(data, dict):
+                    raise ValueError("Failed to verify signature: malformed response")
+                return data
+
             try:
-                return {"signature": str(sig), "valid": True}
-            except Exception:
-                return {"signature": None, "valid": False}
+                verify_cache_result = _call_verify_api(sig_str)
+            except ValueError as exc:
+                verify_cache_error = exc
+                raise
+            return verify_cache_result
 
         def _argparse(args, character=None, splitter=avrae_argparser.argsplit, parse_ephem=True):
             return avrae_argparser.argparse(args, character=character, splitter=splitter, parse_ephem=parse_ephem)
@@ -449,12 +563,20 @@ def _literal_gvars(code: str) -> Set[str]:
 
     gvars: set[str] = set()
     for node in ast.walk(tree):
-        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "get_gvar":
-            if not node.args:
-                continue
-            arg = node.args[0]
-            if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
-                gvars.add(arg.value)
-            elif isinstance(arg, ast.Str):
-                gvars.add(arg.s)
+        if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
+            if node.func.id == "get_gvar":
+                if not node.args:
+                    continue
+                arg = node.args[0]
+                if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
+                    gvars.add(arg.value)
+                elif isinstance(arg, ast.Str):
+                    gvars.add(arg.s)
+            elif node.func.id == "using":
+                for kw in node.keywords:
+                    val = kw.value
+                    if isinstance(val, ast.Constant) and isinstance(val.value, str):
+                        gvars.add(val.value)
+                    elif isinstance(val, ast.Str):
+                        gvars.add(val.s)
     return gvars

avrae_ls/server.py

@@ -68,7 +68,7 @@ class AvraeLanguageServer(LanguageServer):
 
     def load_workspace(self, root: Path) -> None:
         config, warnings = load_config(root)
-        executor = MockExecutor()
+        executor = MockExecutor(config.service)
         context_builder = ContextBuilder(config)
         diagnostics = DiagnosticProvider(executor, config.diagnostics)
         self._state = ServerState(

avrae_ls/signature_help.py

@@ -45,26 +45,80 @@ def _builtin_sigs() -> Dict[str, FunctionSig]:
 
 def _runtime_helper_sigs() -> Dict[str, FunctionSig]:
     helpers = {
-        "get_gvar": ["address"],
-        "get_svar": ["name", "default=None"],
-        "get_cvar": ["name", "default=None"],
-        "get_uvar": ["name", "default=None"],
-        "get_uvars": [],
-        "set_uvar": ["name", "value"],
-        "set_uvar_nx": ["name", "value"],
-        "delete_uvar": ["name"],
-        "uvar_exists": ["name"],
-        "exists": ["name"],
-        "get": ["name", "default=None"],
-        "using": ["**imports"],
-        "signature": ["data=0"],
-        "verify_signature": ["sig"],
-        "print": ["*values"],
-        "character": [],
-        "combat": [],
-        "argparse": ["args", "character=None", "splitter=argsplit", "parse_ephem=True"],
+        "get_gvar": (
+            ["address"],
+            "Retrieves and returns the value of a global variable (gvar) by address.",
+        ),
+        "get_svar": (
+            ["name", "default=None"],
+            "Gets a server variable by name, returning default if it is not present.",
+        ),
+        "get_cvar": (
+            ["name", "default=None"],
+            "Gets a character variable by name as a string, returning default if it is not present.",
+        ),
+        "get_uvar": (
+            ["name", "default=None"],
+            "Gets a user variable by name as a string, returning default if it is not present.",
+        ),
+        "get_uvars": (
+            [],
+            "Returns the mapping of user variables available to the caller (values are strings).",
+        ),
+        "set_uvar": (
+            ["name", "value"],
+            "Sets a user variable (stored as a string) and returns the stored value.",
+        ),
+        "set_uvar_nx": (
+            ["name", "value"],
+            "Sets a user variable only if it does not already exist; returns the stored string value.",
+        ),
+        "delete_uvar": (
+            ["name"],
+            "Deletes a user variable and returns its previous value or None if missing.",
+        ),
+        "uvar_exists": (
+            ["name"],
+            "Returns whether a user variable is set.",
+        ),
+        "exists": (
+            ["name"],
+            "Returns whether a name is set in the current evaluation context.",
+        ),
+        "get": (
+            ["name", "default=None"],
+            "Gets the value of a name using local > cvar > uvar resolution order; returns default if not set.",
+        ),
+        "using": (
+            ["**imports"],
+            "Imports one or more gvars as modules into the current namespace with the provided aliases.",
+        ),
+        "signature": (
+            ["data=0"],
+            "Generates a signed invocation signature encoding invocation context and optional 5-bit user data.",
+        ),
+        "verify_signature": (
+            ["data"],
+            "Verifies a signature generated by signature(); returns context data or raises ValueError when invalid.",
+        ),
+        "print": (
+            ["*values"],
+            "Writes values to alias output using the configured separator/end (mirrors Python print).",
+        ),
+        "character": (
+            [],
+            "Returns the active character object for this alias, or raises if none is available.",
+        ),
+        "combat": (
+            [],
+            "Returns the current combat context if one exists, otherwise None.",
+        ),
+        "argparse": (
+            ["args", "character=None", "splitter=argsplit", "parse_ephem=True"],
+            "Parses alias arguments using Avrae's argparse helper.",
+        ),
     }
-    return {name: FunctionSig(name=name, params=params) for name, params in helpers.items()}
+    return {name: FunctionSig(name=name, params=params, doc=doc) for name, (params, doc) in helpers.items()}
 
 
 def _avrae_function_sigs() -> Dict[str, FunctionSig]:

{avrae_ls-0.2.1.dist-info → avrae_ls-0.3.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: avrae-ls
-Version: 0.2.1
+Version: 0.3.1
 Summary: Language server for Avrae draconic aliases
 Author: 1drturtle
 Requires-Python: >=3.11
@@ -23,7 +23,7 @@ Language Server Protocol (LSP) implementation targeting Avrae-style draconic ali
 
 ## Install (released package)
 
-- CLI/server via `uv tool` (preferred): `uv tool install avrae-ls` then `uv tool run avrae-ls --help` to see stdio/TCP options (same as `python -m avrae_ls`). The VS Code extension uses this invocation by default. The draconic interpreter is vendored, so no Git deps are needed.
+- CLI/server via `uv tool` (preferred): `uv tool install avrae-ls` then `avrae-ls --help` to see stdio/TCP options (same as `python -m avrae_ls`). The VS Code extension uses this invocation by default. The draconic interpreter is vendored, so no Git deps are needed.
 
 ## VS Code extension (released)
 
@@ -37,10 +37,11 @@ Language Server Protocol (LSP) implementation targeting Avrae-style draconic ali
 - Build everything locally: `make package` (wheel + VSIX in `dist/`).
 - Run tests/lint: `make check`.
 - Run via uv tool from source: `uv tool install --from . avrae-ls`.
+- Run diagnostics for a single file (stdout + stderr logs): `avrae-ls --analyze path/to/alias.txt --log-level DEBUG`.
 
 ## Releasing (maintainers)
 
 1. Bump `pyproject.toml` version.
-2. `make release` (clean, build, `twine check`, upload to PyPI).
+2. `make release` (clean, build, upload to PyPI).
 3. Build and attach the VSIX to the GitHub release (`make vsix`).
 4. Tag and push.

{avrae_ls-0.2.1.dist-info → avrae_ls-0.3.1.dist-info}/RECORD

@@ -1,21 +1,21 @@
 avrae_ls/__init__.py,sha256=BmjrnksGkbG7TPqwbyQvgYj9uei8pFSFpfkRpaGVdJU,63
-avrae_ls/__main__.py,sha256=7Osdjqme9unqaGKIHchxVf31egPFlI4_KpBWZvXKpUE,826
+avrae_ls/__main__.py,sha256=ch287lWe11go5xHAE9OkVppixt0vRF401E4zTs2tqQ0,3557
 avrae_ls/alias_preview.py,sha256=Wy_ZNRq73ojPiLFf6P6fJ7rG7DeFFsFLkLlhFrAjkKI,6117
-avrae_ls/api.py,sha256=7kKxFmrvghM4_gv59uRp94DH2MxnVspyjQROT1bY_NE,59430
+avrae_ls/api.py,sha256=sGbwWs5o6M49lyk3qZi6gNdSH_u_BMdghsTlAjpviqQ,64852
 avrae_ls/argparser.py,sha256=-6RKrXavbSjEyyEeaoz8hRamnB-MEmJt3Cw2smRbmdI,13483
 avrae_ls/argument_parsing.py,sha256=ezKl65VwuNEDxt6KlYwVQcpy1110UDvf4BqZqgZTcqk,2122
-avrae_ls/completions.py,sha256=RAKwDemcg0EUZkc7ncoPO5mKZ8e0cWN2pMt8XKirB9o,18835
+avrae_ls/completions.py,sha256=WSyP967_t_oBhRMjLk-QQKyXWiNh4sJTH560VdMBQeg,34336
 avrae_ls/config.py,sha256=C51wfG6-82uX4dsffqcDLMiXbZZL9JQgfpulAr8eiqs,15267
-avrae_ls/context.py,sha256=jAV0GbpqHrD7jvWYNcOeh-hUcnPLsMFX8Emo48Jc59U,5122
+avrae_ls/context.py,sha256=w0uVSR6Pis3q1fF3kSPsqbTirKOE6n3k2XMO8UZI7sk,5719
 avrae_ls/cvars.py,sha256=0tcVbUHx_CKJ6aou3kEsKX37LRWAjkUWlqqIuSRFlXk,3197
-avrae_ls/diagnostics.py,sha256=a0x8CWTQbapno0JOFVw75gYZnPak4uQ0fySr9B8_xj0,15440
+avrae_ls/diagnostics.py,sha256=EAdbckvvWu0pswopaZ6JyVGCHXUl5ZvGBhP2PDVCrVw,16180
 avrae_ls/dice.py,sha256=DY7V7L-EwAXaCgddgVe9xU1s9lVtiw5Zc2reipNgdTk,874
 avrae_ls/parser.py,sha256=AuNxNkkfquN9dcyTpmzAZxWcAQ7CV3PQLHUDYLMz_7U,1148
-avrae_ls/runtime.py,sha256=HFBCyL0oR4D91z0x4Id8rl6nhPZl3HINHJyBfoVn3Pk,15115
-avrae_ls/server.py,sha256=8togXNRC5aM2fX2sss7V-aedkbJBPM7dmawc57_IU7g,13056
-avrae_ls/signature_help.py,sha256=S9VnmmvD_CvFQLPuWMlo33eRAhmNi_CsRpWFcoRY6Rk,4823
+avrae_ls/runtime.py,sha256=sSN_C48TrF7F5NtsUpgHr_cZyYX6HCQHBfCpAYxsDJo,20792
+avrae_ls/server.py,sha256=L3qGTpCDOa64hWFmfWfoKbrDZ3262gmu5wYhHkdLBPY,13070
+avrae_ls/signature_help.py,sha256=JheaEzINV4FO72t5U0AJfL2ZX15y3-gcA6xk3M1jHcY,6980
 avrae_ls/symbols.py,sha256=8aMalHBDnRsRvhwdbmf0nOazio7G185qw9le45Xb5Mk,4449
-avrae_ls-0.2.1.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
+avrae_ls-0.3.1.dist-info/licenses/LICENSE,sha256=O-0zMbcEi6wXz1DiSdVgzMlQjJcNqNe5KDv08uYzqR0,1055
 draconic/LICENSE,sha256=Fzvu32_DafLKKn2mzxhEdlmrKZzAsigDZ87O7uoVqZI,1067
 draconic/__init__.py,sha256=YPH420Pcn_nTkfB62hJy_YqC5kpJdzSa78jP8n4z_xY,109
 draconic/exceptions.py,sha256=siahnHIsumbaUhKBDSrw_DmLZ-0oZks8L5oytPH8hD4,3753
@@ -25,8 +25,8 @@ draconic/string.py,sha256=kGrRc6wNHRq1y5xw8Os-fBhfINDtIY2nBWQWkyLSfQI,2858
 draconic/types.py,sha256=1Lsr6z8bW5agglGI4hLt_nPtYuZOIf_ueSpPDB4WDrs,13686
 draconic/utils.py,sha256=D4vJ-txqS2-rlqsEpXAC46_j1sZX4UjY-9zIgElo96k,3122
 draconic/versions.py,sha256=CUEsgUWjAmjez0432WwiBwZlIzWPIObwZUf8Yld18EE,84
-avrae_ls-0.2.1.dist-info/METADATA,sha256=ukIqEUjW7AT9Ry2CeW4U9nFsDUJ4Clwfa-mbFpjv0SQ,2016
-avrae_ls-0.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-avrae_ls-0.2.1.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
-avrae_ls-0.2.1.dist-info/top_level.txt,sha256=TL68uzGHmB2R2ID32_s2zocmcNnpMJVQ6_4NBvyo8a4,18
-avrae_ls-0.2.1.dist-info/RECORD,,
+avrae_ls-0.3.1.dist-info/METADATA,sha256=TRJQs5mkNC4TPeYBkO2rXDnvkJhjf2jws1ginLXaXq4,2107
+avrae_ls-0.3.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+avrae_ls-0.3.1.dist-info/entry_points.txt,sha256=OtYXipMQzqmxpMoApgo0MeJYFmMbkbFN51Ibhpb8hF4,52
+avrae_ls-0.3.1.dist-info/top_level.txt,sha256=TL68uzGHmB2R2ID32_s2zocmcNnpMJVQ6_4NBvyo8a4,18
+avrae_ls-0.3.1.dist-info/RECORD,,