chore: code formatting

Author: 1drturtle

src/avrae_ls/analysis/diagnostics.py

@@ -83,16 +83,12 @@ async def _analyze_code(
             diagnostics.append(_syntax_from_std(exc))
             return diagnostics
 
-        diagnostics.extend(
-            self._check_unknown_names(body, ctx_data, self._settings.semantic_level)
-        )
+        diagnostics.extend(self._check_unknown_names(body, ctx_data, self._settings.semantic_level))
         diagnostics.extend(await _check_gvars(body, gvar_resolver, self._settings))
         diagnostics.extend(_check_imports(body, self._settings.semantic_level))
         diagnostics.extend(_check_call_args(body, self._builtin_signatures, self._settings.semantic_level))
         diagnostics.extend(_check_private_method_calls(body))
-        diagnostics.extend(
-            _check_api_misuse(body, code, ctx_data, self._settings.semantic_level)
-        )
+        diagnostics.extend(_check_api_misuse(body, code, ctx_data, self._settings.semantic_level))
         if line_shift:
             diagnostics = _shift_diagnostics(diagnostics, line_shift, 0)
         return diagnostics
@@ -460,7 +456,11 @@ def _uncalled_context_attr_diagnostics(
     assigned_names: Set[str],
     severity_level: str,
 ) -> List[types.Diagnostic]:
-    if isinstance(node.value, ast.Name) and node.value.id in {"character", "combat"} and node.value.id not in assigned_names:
+    if (
+        isinstance(node.value, ast.Name)
+        and node.value.id in {"character", "combat"}
+        and node.value.id not in assigned_names
+    ):
         call_hint = f"{node.value.id}()"
         return [
             _make_diagnostic(
@@ -599,7 +599,7 @@ def _make_diagnostic(
         rng = types.Range(
             start=types.Position(line=0, character=0),
             end=types.Position(line=0, character=1),
-    )
+        )
     return types.Diagnostic(
         message=message,
         range=rng,
@@ -629,8 +629,6 @@ def _shift_diagnostics(diags: List[types.Diagnostic], line_offset: int, char_off
     return shifted
 
 
-
-
 def _build_builtin_signatures() -> dict[str, inspect.Signature]:
     sigs: dict[str, inspect.Signature] = {}
     builtins = _default_builtins()

src/avrae_ls/analysis/parser.py

@@ -57,12 +57,16 @@ def _block_from_match(match: re.Match[str], inline: bool = False) -> tuple[int,
             line_offset += 1
             char_offset = 0
         line_count = raw.count("\n") + 1 if raw else 1
-        return match.start(), match.end(), DraconicBlock(
-            code=raw,
-            line_offset=line_offset,
-            char_offset=char_offset,
-            line_count=line_count,
-            inline=inline,
+        return (
+            match.start(),
+            match.end(),
+            DraconicBlock(
+                code=raw,
+                line_offset=line_offset,
+                char_offset=char_offset,
+                line_count=line_count,
+                inline=inline,
+            ),
         )
 
     blocks: list[DraconicBlock] = []

src/avrae_ls/analysis/symbols.py

@@ -87,9 +87,7 @@ def find_references(
         ranges.extend(_references_from_code(source_ctx.prepared, name, 0, 0, include_stores))
     else:
         for block in source_ctx.blocks:
-            ranges.extend(
-                _references_from_code(block.code, name, block.line_offset, block.char_offset, include_stores)
-            )
+            ranges.extend(_references_from_code(block.code, name, block.line_offset, block.char_offset, include_stores))
     return _dedupe_ranges(ranges)
 
 

src/avrae_ls/config.py

@@ -238,7 +238,12 @@ def _mod(score: int) -> int:
             ],
             "skills": skills,
             "saves": saves,
-            "resistances": {"resist": [{"dtype": "fire", "unless": [], "only": []}], "vuln": [], "immune": [], "neutral": []},
+            "resistances": {
+                "resist": [{"dtype": "fire", "unless": [], "only": []}],
+                "vuln": [],
+                "immune": [],
+                "neutral": [],
+            },
             "spellbook": spellbook,
             "consumables": consumables,
             "cvars": {"favorite_enemy": "goblinoids", "fighting_style": "defense"},
@@ -303,13 +308,29 @@ def _mod(score: int) -> int:
             "type": "combatant",
             "note": "",
             "effects": [],
-            "stats": {"strength": 8, "dexterity": 14, "constitution": 10, "intelligence": 8, "wisdom": 10, "charisma": 8, "prof_bonus": 2},
+            "stats": {
+                "strength": 8,
+                "dexterity": 14,
+                "constitution": 10,
+                "intelligence": 8,
+                "wisdom": 10,
+                "charisma": 8,
+                "prof_bonus": 2,
+            },
             "levels": {},
             "skills": {"stealth": {"value": 6, "prof": 1, "bonus": 0, "adv": None}},
             "saves": {"dex": 4},
             "resistances": {"resist": [], "vuln": [], "immune": [], "neutral": []},
             "spellbook": {"spells": []},
-            "attacks": [{"name": "Scimitar", "verb": "slashes", "proper": False, "activation_type": 1, "raw": {"name": "Scimitar", "bonus": "+4", "damage": "1d6+2 slashing"}}],
+            "attacks": [
+                {
+                    "name": "Scimitar",
+                    "verb": "slashes",
+                    "proper": False,
+                    "activation_type": 1,
+                    "raw": {"name": "Scimitar", "bonus": "+4", "damage": "1d6+2 slashing"},
+                }
+            ],
             "max_hp": 11,
             "hp": 11,
             "temp_hp": 0,
@@ -370,6 +391,7 @@ def _expand_env_vars(data: Any, env: Mapping[str, str], missing_vars: set[str])
     if isinstance(data, list):
         return [_expand_env_vars(value, env, missing_vars) for value in data]
     if isinstance(data, str):
+
         def _replace(match: re.Match[str]) -> str:
             var = match.group(1) or match.group(2) or ""
             if var in env:
@@ -388,7 +410,9 @@ def _coerce_optional_str(value: Any) -> str | None:
     return value_str if value_str.strip() else None
 
 
-def load_config(workspace_root: Path, *, default_enable_gvar_fetch: bool = False) -> Tuple[AvraeLSConfig, Iterable[str]]:
+def load_config(
+    workspace_root: Path, *, default_enable_gvar_fetch: bool = False
+) -> Tuple[AvraeLSConfig, Iterable[str]]:
     """Load `.avraels.json` from the workspace root, returning config and warnings."""
     path = workspace_root / CONFIG_FILENAME
     if not path.exists():
@@ -448,9 +472,7 @@ def load_config(workspace_root: Path, *, default_enable_gvar_fetch: bool = False
 
     default_profile = str(raw.get("defaultProfile") or "default")
     if default_profile not in profiles and profiles:
-        warnings.append(
-            f"defaultProfile '{default_profile}' not found; falling back to first profile in file."
-        )
+        warnings.append(f"defaultProfile '{default_profile}' not found; falling back to first profile in file.")
         default_profile = next(iter(profiles))
 
     if not profiles:

src/avrae_ls/lsp/code_actions.py

@@ -148,7 +148,7 @@ def _rewrite_import_action(
     module: str | None,
 ) -> types.CodeAction:
     target = module or "module"
-    replacement = f"using({target}=\"<gvar-id>\")"
+    replacement = f'using({target}="<gvar-id>")'
     edit = types.TextEdit(range=diag.range, new_text=replacement)
     return types.CodeAction(
         title="Replace import with using()",

src/avrae_ls/lsp/completions.py

@@ -141,7 +141,9 @@ def completion_items_for_position(
     return items
 
 
-def _attribute_completions(receiver: str, prefix: str, code: str, type_map: Dict[str, str] | None = None) -> List[types.CompletionItem]:
+def _attribute_completions(
+    receiver: str, prefix: str, code: str, type_map: Dict[str, str] | None = None
+) -> List[types.CompletionItem]:
     items: list[types.CompletionItem] = []
     type_key = resolve_type_name(receiver, code, type_map)
     if IDENT_RE.fullmatch(receiver) and (not type_map or receiver not in type_map) and type_key == receiver:
@@ -384,7 +386,9 @@ def visit_ExceptHandler(self, node: ast.ExceptHandler):
     return names
 
 
-def _attribute_receiver_and_prefix(code: str, line: int, character: int, capture_full_token: bool = False) -> Optional[tuple[str, str]]:
+def _attribute_receiver_and_prefix(
+    code: str, line: int, character: int, capture_full_token: bool = False
+) -> Optional[tuple[str, str]]:
     lines = code.splitlines()
     if line >= len(lines):
         return None
@@ -393,7 +397,7 @@ def _attribute_receiver_and_prefix(code: str, line: int, character: int, capture
     if capture_full_token:
         while end < len(line_text) and (line_text[end].isalnum() or line_text[end] == "_"):
             end += 1
-    line_text = line_text[: end]
+    line_text = line_text[:end]
     dot = line_text.rfind(".")
     if dot == -1:
         return None

src/avrae_ls/lsp/server.py

@@ -22,7 +22,13 @@
 from avrae_ls.lsp.signature_help import load_signatures, signature_help_for_code
 from avrae_ls.lsp.completions import gather_suggestions, completion_items_for_position, hover_for_position
 from avrae_ls.lsp.code_actions import code_actions_for_document
-from avrae_ls.analysis.symbols import build_symbol_table, document_symbols, find_definition_range, find_references, range_for_word
+from avrae_ls.analysis.symbols import (
+    build_symbol_table,
+    document_symbols,
+    find_definition_range,
+    find_references,
+    range_for_word,
+)
 
 # Prefer package metadata so the server version matches the installed wheel.
 try:
@@ -106,9 +112,7 @@ def on_initialize(server: AvraeLanguageServer, params: types.InitializeParams):
 @ls.feature(types.INITIALIZED)
 async def on_initialized(server: AvraeLanguageServer, params: types.InitializedParams):
     for warning in server.state.warnings:
-        server.window_log_message(
-            types.LogMessageParams(type=types.MessageType.Warning, message=warning)
-        )
+        server.window_log_message(types.LogMessageParams(type=types.MessageType.Warning, message=warning))
 
 
 @ls.feature(types.TEXT_DOCUMENT_DID_OPEN)
@@ -130,9 +134,7 @@ async def did_save(server: AvraeLanguageServer, params: types.DidSaveTextDocumen
 async def did_change_config(server: AvraeLanguageServer, params: types.DidChangeConfigurationParams):
     server.load_workspace(server.workspace_root)
     for warning in server.state.warnings:
-        server.window_log_message(
-            types.LogMessageParams(type=types.MessageType.Warning, message=warning)
-        )
+        server.window_log_message(types.LogMessageParams(type=types.MessageType.Warning, message=warning))
 
 
 @ls.feature(types.TEXT_DOCUMENT_DOCUMENT_SYMBOL)
@@ -336,9 +338,7 @@ async def run_alias(server: AvraeLanguageServer, *args: Any):
         if rendered.error:
             src = doc.source if doc else text
             extra.append(
-                _runtime_diagnostic_with_source(
-                    rendered.error, server.state.config.diagnostics.runtime_level, src
-                )
+                _runtime_diagnostic_with_source(rendered.error, server.state.config.diagnostics.runtime_level, src)
             )
         await _publish_diagnostics(server, uri, profile=profile, extra=extra)
     return response
@@ -393,6 +393,7 @@ def _format_runtime_error(error: BaseException) -> str:
         return error.msg
     return str(error)
 
+
 def _runtime_diagnostic_with_source(error: BaseException, level: str, source: str | None) -> types.Diagnostic:
     severity = LEVEL_TO_SEVERITY.get(level.lower(), types.DiagnosticSeverity.Error)
     if source and hasattr(error, "module"):
@@ -411,7 +412,9 @@ def _runtime_diagnostic_with_source(error: BaseException, level: str, source: st
     elif hasattr(error, "node"):
         node = getattr(error, "node")
         rng = types.Range(
-            start=types.Position(line=max(getattr(node, "lineno", 1) - 1, 0), character=max(getattr(node, "col_offset", 0), 0)),
+            start=types.Position(
+                line=max(getattr(node, "lineno", 1) - 1, 0), character=max(getattr(node, "col_offset", 0), 0)
+            ),
             end=types.Position(
                 line=max(getattr(node, "end_lineno", getattr(node, "lineno", 1)) - 1, 0),
                 character=max(getattr(node, "end_col_offset", getattr(node, "col_offset", 0) + 1), 0),

src/avrae_ls/lsp/signature_help.py

@@ -146,7 +146,9 @@ def _avrae_function_sigs() -> Dict[str, FunctionSig]:
     return sigs
 
 
-def signature_help_for_code(code: str, line: int, character: int, sigs: Dict[str, FunctionSig]) -> Optional[types.SignatureHelp]:
+def signature_help_for_code(
+    code: str, line: int, character: int, sigs: Dict[str, FunctionSig]
+) -> Optional[types.SignatureHelp]:
     try:
         tree = ast.parse(code)
     except SyntaxError:

src/avrae_ls/runtime/alias_preview.py

@@ -152,7 +152,7 @@ async def render_alias_command(
     for kind, match in matches:
         if match.start() < pos:
             continue
-        parts.append(body[pos: match.start()])
+        parts.append(body[pos : match.start()])
 
         if kind in {"block", "inline"}:
             code = match.group(1)
@@ -304,7 +304,7 @@ def _validate_field_arg(value: str | None) -> Tuple[bool, str | None, int]:
     assert value is not None  # for type checker
     parts = value.split("|")
     if len(parts) < 2 or len(parts) > 3:
-        return False, "Embed field must be in the form \"Title|Text[|inline]\".", consumed
+        return False, 'Embed field must be in the form "Title|Text[|inline]".', consumed
     if not parts[0] or not parts[1]:
         return False, "Embed field title and text cannot be empty.", consumed
     if len(parts) == 3 and parts[2].lower() not in ("inline", ""):

src/avrae_ls/runtime/api.py

@@ -1352,7 +1352,9 @@ def get_cc_min(self, name: str) -> int:
         """Minimum value for a custom counter."""
         return self.cc(name).min
 
-    def set_cc(self, name: str, value: int | None = None, maximum: int | None = None, minimum: int | None = None) -> int:
+    def set_cc(
+        self, name: str, value: int | None = None, maximum: int | None = None, minimum: int | None = None
+    ) -> int:
         """Set value/max/min for a custom counter."""
         con = self._consumable_map().setdefault(str(name), {"name": str(name)})
         if value is not None:
@@ -1697,7 +1699,11 @@ def damage(
         except Exception:
             roll_result = d20.roll("0")
         label = "Damage (CRIT!)" if crit else "Damage"
-        return {"damage": f"**{label}**: {roll_result}", "total": roll_result.total, "roll": SimpleRollResult(roll_result)}
+        return {
+            "damage": f"**{label}**: {roll_result}",
+            "total": roll_result.total,
+            "roll": SimpleRollResult(roll_result),
+        }
 
     def set_ac(self, ac: int) -> None:
         """Set armor class."""
@@ -1856,7 +1862,15 @@ def set_init(self, init: int) -> None:
 class SimpleCombat(_ItemAccessMixin, _DirMixin):
     _data: MutableMapping[str, Any] = field(default_factory=dict)
     ATTRS: ClassVar[list[str]] = ["combatants", "groups", "me", "current", "name", "round_num", "turn_num", "metadata"]
-    METHODS: ClassVar[list[str]] = ["get_combatant", "get_group", "set_metadata", "get_metadata", "delete_metadata", "set_round", "end_round"]
+    METHODS: ClassVar[list[str]] = [
+        "get_combatant",
+        "get_group",
+        "set_metadata",
+        "get_metadata",
+        "delete_metadata",
+        "set_round",
+        "end_round",
+    ]
 
     @property
     def combatants(self) -> list[SimpleCombatant]: