neml2-langserv 0.1.1__tar.gz

neml2_langserv-0.1.1/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: neml2-langserv
+Version: 0.1.1
+Summary: Language server backing the NEML2 VS Code extension
+Project-URL: Homepage, https://github.com/applied-material-modeling/neml2-langserv
+Project-URL: Issues, https://github.com/applied-material-modeling/neml2-langserv/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pygls>=1.3
+Requires-Dist: neml2>=2.1.4
+Requires-Dist: nmhit>=0.1.2
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+
+# NEML2 Language Support
+
+VS Code extension providing language support for [NEML2](https://github.com/applied-material-modeling/neml2) input files.
+
+## Features
+
+- **Completion** — type names for `type = ` assignments, and option names with inline type hints inside typed blocks
+- **Hover documentation** — docstrings for types and options shown on hover
+- **Format on save** — re-indents the document consistently via the `nmhit` formatter
+
+## Requirements
+
+A Python environment with the [`neml2-langserv`](https://pypi.org/project/neml2-langserv/) package installed:
+
+```
+pip install neml2-langserv
+```
+
+That single install pulls in everything the language server needs — [`neml2`](https://pypi.org/project/neml2/) (≥ 2.1.4) for the type/option metadata, [`nmhit`](https://pypi.org/project/nmhit/) (≥ 0.1.2) for the formatter, and `pygls` for the LSP transport.
+
+The extension runs the server with whichever Python interpreter is selected in the [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python). If `neml2-langserv` is not installed in that interpreter on first activation, the extension prompts you to install it.
+
+## Setup
+
+NEML2 input files share the `.i` extension with MOOSE input files. To tell the extension that a file is a NEML2 input, add the following as the **first line**:
+
+```
+# neml2
+```
+
+Files without this marker are treated as MOOSE input (or plain text) and the NEML2 language server will not activate for them.
+
+## Format on save
+
+Enable the built-in VS Code setting to auto-format on save:
+
+```jsonc
+// .vscode/settings.json
+{
+  "[neml2]": {
+    "editor.formatOnSave": true
+  }
+}
+```
+
+## MOOSE compatibility
+
+This extension does **not** claim the `.i` extension globally, so existing MOOSE workflows are unaffected. Only files whose first line matches `# neml2` (optionally followed by other text) are switched to the `neml2` language mode.

neml2_langserv-0.1.1/README.md

@@ -0,0 +1,48 @@
+# NEML2 Language Support
+
+VS Code extension providing language support for [NEML2](https://github.com/applied-material-modeling/neml2) input files.
+
+## Features
+
+- **Completion** — type names for `type = ` assignments, and option names with inline type hints inside typed blocks
+- **Hover documentation** — docstrings for types and options shown on hover
+- **Format on save** — re-indents the document consistently via the `nmhit` formatter
+
+## Requirements
+
+A Python environment with the [`neml2-langserv`](https://pypi.org/project/neml2-langserv/) package installed:
+
+```
+pip install neml2-langserv
+```
+
+That single install pulls in everything the language server needs — [`neml2`](https://pypi.org/project/neml2/) (≥ 2.1.4) for the type/option metadata, [`nmhit`](https://pypi.org/project/nmhit/) (≥ 0.1.2) for the formatter, and `pygls` for the LSP transport.
+
+The extension runs the server with whichever Python interpreter is selected in the [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python). If `neml2-langserv` is not installed in that interpreter on first activation, the extension prompts you to install it.
+
+## Setup
+
+NEML2 input files share the `.i` extension with MOOSE input files. To tell the extension that a file is a NEML2 input, add the following as the **first line**:
+
+```
+# neml2
+```
+
+Files without this marker are treated as MOOSE input (or plain text) and the NEML2 language server will not activate for them.
+
+## Format on save
+
+Enable the built-in VS Code setting to auto-format on save:
+
+```jsonc
+// .vscode/settings.json
+{
+  "[neml2]": {
+    "editor.formatOnSave": true
+  }
+}
+```
+
+## MOOSE compatibility
+
+This extension does **not** claim the `.i` extension globally, so existing MOOSE workflows are unaffected. Only files whose first line matches `# neml2` (optionally followed by other text) are switched to the `neml2` language mode.

neml2_langserv-0.1.1/neml2_langserv/__main__.py

@@ -0,0 +1,19 @@
+import argparse
+
+from .server import server
+
+
+def main() -> None:
+    parser = argparse.ArgumentParser(description="NEML2 Language Server")
+    parser.add_argument("--stdio", action="store_true", help="use stdio transport")
+    parser.add_argument("--tcp", type=int, metavar="PORT", help="use TCP transport on PORT")
+    args = parser.parse_args()
+
+    if args.tcp:
+        server.start_tcp("127.0.0.1", args.tcp)
+    else:
+        server.start_io()
+
+
+if __name__ == "__main__":
+    main()

neml2_langserv-0.1.1/neml2_langserv/hit_parser.py

@@ -0,0 +1,129 @@
+"""Tolerant HIT document context parser.
+
+Uses only bracket delimiters ([name] / []) — no indentation logic.
+Bracket depth:  0 = file root, 1 = top-level section, 2 = sub-block.
+"""
+
+import re
+from dataclasses import dataclass, field
+
+_OPEN = re.compile(r"^\s*\[([^\]/][^\]]*)\]\s*(?:#.*)?$")
+_CLOSE = re.compile(r"^\s*\[\]\s*(?:#.*)?$")
+_KV = re.compile(r"^\s*(\w[\w/]*)\s*[:=]=?\s*(.*?)\s*(?:#.*)?$")
+
+
+@dataclass
+class BlockContext:
+    section: str = ""
+    block_name: str = ""
+    block_type: str = ""
+    options_set: set[str] = field(default_factory=set)
+
+
+def get_context(lines: list[str], cursor_line: int) -> BlockContext | None:
+    """Return the HIT context at *cursor_line* (0-indexed)."""
+    depth = 0
+    ctx = BlockContext()
+
+    for i, line in enumerate(lines):
+        if i > cursor_line:
+            break
+
+        close = _CLOSE.match(line)
+        if close:
+            if depth == 2:
+                ctx.block_name = ""
+                ctx.block_type = ""
+                ctx.options_set = set()
+            if depth == 1:
+                ctx.section = ""
+            depth = max(0, depth - 1)
+            continue
+
+        open_m = _OPEN.match(line)
+        if open_m:
+            name = open_m.group(1).strip()
+            if depth == 0:
+                ctx.section = name
+                depth = 1
+            elif depth == 1:
+                ctx.block_name = name
+                ctx.block_type = ""
+                ctx.options_set = set()
+                depth = 2
+            continue
+
+        if depth == 2:
+            kv = _KV.match(line)
+            if kv:
+                key, val = kv.group(1), kv.group(2).strip()
+                if key == "type":
+                    ctx.block_type = val.strip("'\"")
+                else:
+                    ctx.options_set.add(key)
+
+    if depth < 2:
+        return None
+    return ctx
+
+
+@dataclass
+class ParsedBlock:
+    context: BlockContext
+    start_line: int
+    end_line: int
+
+
+def parse_all_blocks(lines: list[str]) -> list[ParsedBlock]:
+    """Return every sub-block found in the document."""
+    blocks: list[ParsedBlock] = []
+    depth = 0
+    section = ""
+    block_name = ""
+    block_type = ""
+    options_set: set[str] = set()
+    block_start = 0
+
+    for i, line in enumerate(lines):
+        close = _CLOSE.match(line)
+        if close:
+            if depth == 2:
+                blocks.append(
+                    ParsedBlock(
+                        BlockContext(section, block_name, block_type, options_set),
+                        block_start,
+                        i,
+                    )
+                )
+                block_name = ""
+                block_type = ""
+                options_set = set()
+            elif depth == 1:
+                section = ""
+            depth = max(0, depth - 1)
+            continue
+
+        open_m = _OPEN.match(line)
+        if open_m:
+            name = open_m.group(1).strip()
+            if depth == 0:
+                section = name
+                depth = 1
+            elif depth == 1:
+                block_name = name
+                block_type = ""
+                options_set = set()
+                block_start = i
+                depth = 2
+            continue
+
+        if depth == 2:
+            kv = _KV.match(line)
+            if kv:
+                key, val = kv.group(1), kv.group(2).strip()
+                if key == "type":
+                    block_type = val.strip("'\"")
+                else:
+                    options_set.add(key)
+
+    return blocks

neml2_langserv-0.1.1/neml2_langserv/server.py

@@ -0,0 +1,240 @@
+import re
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _pkg_version
+
+import nmhit
+from lsprotocol import types as lsp
+from pygls.lsp.server import LanguageServer
+
+from .hit_parser import get_context, parse_all_blocks
+from .syntax_client import NEML2_MIN_VERSION, NMHIT_MIN_VERSION, get_client
+
+server = LanguageServer("neml2-ls", "v0.1")
+
+def _version_tuple(v: str) -> tuple[int, ...]:
+    return tuple(int(x) for x in v.split(".")[:3])
+
+
+def _check_pkg(pkg: str, min_ver: str) -> str | None:
+    """Return a warning string if pkg is missing or below min_ver, else None."""
+    try:
+        installed = _pkg_version(pkg)
+        if _version_tuple(installed) < _version_tuple(min_ver):
+            return (
+                f"'{pkg}' {installed} is installed but >={min_ver} is required. "
+                "Some features may not work correctly."
+            )
+    except PackageNotFoundError:
+        return (
+            f"'{pkg}' is not installed (>={min_ver} required). "
+            "Please install it in the active Python environment."
+        )
+    return None
+
+
+@server.feature(lsp.INITIALIZED)
+def _on_initialized(ls: LanguageServer, params: lsp.InitializedParams) -> None:
+    for pkg, min_ver, severity in [
+        ("neml2", NEML2_MIN_VERSION, lsp.MessageType.Error),
+        ("nmhit", NMHIT_MIN_VERSION, lsp.MessageType.Warning),
+    ]:
+        msg = _check_pkg(pkg, min_ver)
+        if msg:
+            ls.window_show_message(
+                lsp.ShowMessageParams(type=severity, message=f"NEML2: {msg}")
+            )
+
+# ---------------------------------------------------------------------------
+# helpers
+# ---------------------------------------------------------------------------
+
+_FTYPE_KIND = {
+    "PARAMETER": lsp.CompletionItemKind.Variable,
+    "INPUT": lsp.CompletionItemKind.Field,
+    "OUTPUT": lsp.CompletionItemKind.Field,
+    "BUFFER": lsp.CompletionItemKind.Variable,
+    "NONE": lsp.CompletionItemKind.Property,
+}
+
+_TYPE_ASSIGN = re.compile(r"^\s*type\s*[:=]=?\s*\S*$")
+_KEY_POS = re.compile(r"^\s*[\w/]*$")
+
+
+def _doc_lines(lines: list[str]) -> list[str]:
+    """Return document lines (handles both list[str] and str)."""
+    return lines
+
+
+def _word_at(line: str, character: int) -> str:
+    start = character
+    while start > 0 and (line[start - 1].isalnum() or line[start - 1] in "_:/"):
+        start -= 1
+    end = character
+    while end < len(line) and (line[end].isalnum() or line[end] in "_:/"):
+        end += 1
+    return line[start:end]
+
+
+def _fmt_option(opt: dict) -> str:
+    ftype = opt.get("ftype", "")
+    header = f"**{opt['name']}**" + (f"  `{ftype}`" if ftype and ftype != "NONE" else "")
+    lines = [header]
+    if opt.get("type"):
+        lines.append(f"*Type:* `{opt['type']}`")
+    if opt.get("required"):
+        lines.append("*Required*")
+    if opt.get("doc"):
+        lines.append("")
+        lines.append(opt["doc"])
+    return "\n".join(lines)
+
+
+def _get_lines(ls: LanguageServer, uri: str) -> list[str]:
+    doc = ls.workspace.get_text_document(uri)
+    return doc.source.splitlines()
+
+
+# ---------------------------------------------------------------------------
+# completion
+# ---------------------------------------------------------------------------
+
+
+@server.feature(
+    lsp.TEXT_DOCUMENT_COMPLETION,
+    lsp.CompletionOptions(trigger_characters=["=", " ", "\t"]),
+)
+def completions(
+    ls: LanguageServer, params: lsp.CompletionParams
+) -> list[lsp.CompletionItem]:
+    lines = _get_lines(ls, params.text_document.uri)
+    line_idx = params.position.line
+    if line_idx >= len(lines):
+        return []
+
+    current_line = lines[line_idx]
+    ctx = get_context(lines, line_idx)
+    if ctx is None:
+        return []
+
+    syntax = get_client()
+    if syntax is None:
+        return []
+
+    # After `type =` → offer all registered types for this section
+    if _TYPE_ASSIGN.match(current_line):
+        try:
+            types = syntax.list_types(ctx.section)
+        except Exception:
+            return []
+        return [
+            lsp.CompletionItem(
+                label=t["type"],
+                kind=lsp.CompletionItemKind.Class,
+                detail=t["section"],
+                documentation=lsp.MarkupContent(
+                    kind=lsp.MarkupKind.PlainText, value=t.get("doc", "")
+                ),
+            )
+            for t in types
+        ]
+
+    # At an option key position → offer option names for the current type
+    if ctx.block_type and _KEY_POS.match(current_line):
+        try:
+            info = syntax.get_options(ctx.block_type)
+        except Exception:
+            return []
+        if not info:
+            return []
+        remaining = [o for o in info["options"] if o["name"] not in ctx.options_set]
+        return [
+            lsp.CompletionItem(
+                label=o["name"],
+                kind=_FTYPE_KIND.get(o["ftype"], lsp.CompletionItemKind.Property),
+                detail=o.get("type") or "",
+                documentation=lsp.MarkupContent(
+                    kind=lsp.MarkupKind.Markdown, value=_fmt_option(o)
+                ),
+            )
+            for o in remaining
+        ]
+
+    return []
+
+
+# ---------------------------------------------------------------------------
+# hover
+# ---------------------------------------------------------------------------
+
+
+@server.feature(lsp.TEXT_DOCUMENT_HOVER)
+def hover(ls: LanguageServer, params: lsp.HoverParams) -> lsp.Hover | None:
+    lines = _get_lines(ls, params.text_document.uri)
+    line_idx = params.position.line
+    if line_idx >= len(lines):
+        return None
+
+    word = _word_at(lines[line_idx], params.position.character)
+    if not word:
+        return None
+
+    ctx = get_context(lines, line_idx)
+    syntax = get_client()
+    if syntax is None:
+        return None
+
+    # Hover on a type name
+    try:
+        info = syntax.get_options(word)
+        if info:
+            md = f"**{word}** _{info['section']}_\n\n{info.get('doc', '')}"
+            return lsp.Hover(
+                contents=lsp.MarkupContent(kind=lsp.MarkupKind.Markdown, value=md)
+            )
+    except Exception:
+        pass
+
+    # Hover on an option key within a typed block
+    if ctx and ctx.block_type:
+        try:
+            info = syntax.get_options(ctx.block_type)
+            if info:
+                by_name = {o["name"]: o for o in info["options"]}
+                if word in by_name:
+                    return lsp.Hover(
+                        contents=lsp.MarkupContent(
+                            kind=lsp.MarkupKind.Markdown,
+                            value=_fmt_option(by_name[word]),
+                        )
+                    )
+        except Exception:
+            pass
+
+    return None
+
+
+# ---------------------------------------------------------------------------
+# formatting
+# ---------------------------------------------------------------------------
+
+
+@server.feature(lsp.TEXT_DOCUMENT_FORMATTING)
+def formatting(
+    ls: LanguageServer, params: lsp.DocumentFormattingParams
+) -> list[lsp.TextEdit] | None:
+    doc = ls.workspace.get_text_document(params.text_document.uri)
+    source = doc.source
+    try:
+        root = nmhit.parse_text(source)
+        formatted = root.render(indent=0, indent_text="  ")
+    except Exception:
+        return None
+
+    lines = source.splitlines()
+    last_line = len(lines) - 1
+    last_char = len(lines[last_line]) if lines else 0
+    whole_doc = lsp.Range(
+        start=lsp.Position(line=0, character=0),
+        end=lsp.Position(line=last_line, character=last_char),
+    )
+    return [lsp.TextEdit(range=whole_doc, new_text=formatted)]

neml2_langserv-0.1.1/neml2_langserv/syntax_client.py

@@ -0,0 +1,93 @@
+import atexit
+import json
+import subprocess
+import threading
+from importlib.metadata import PackageNotFoundError
+from importlib.metadata import version as _pkg_version
+from pathlib import Path
+from typing import Any
+
+
+NEML2_MIN_VERSION = "2.1.4"
+NMHIT_MIN_VERSION = "0.1.2"
+
+
+def _neml2_ok() -> bool:
+    try:
+        v = _pkg_version("neml2")
+        min_t = tuple(int(x) for x in NEML2_MIN_VERSION.split(".")[:3])
+        return tuple(int(x) for x in v.split(".")[:3]) >= min_t
+    except PackageNotFoundError:
+        return False
+
+
+def _find_binary() -> Path:
+    """Locate the neml2-syntax binary bundled with the neml2 Python package."""
+    for pkg_dir in neml2.__path__:
+        candidate = Path(pkg_dir) / "bin" / "neml2-syntax"
+        if candidate.exists():
+            return candidate
+    searched = [str(Path(p) / "bin" / "neml2-syntax") for p in neml2.__path__]
+    raise RuntimeError(f"neml2-syntax not found; searched: {searched}")
+
+
+class SyntaxClient:
+    """Long-lived wrapper around `neml2-syntax --server`."""
+
+    def __init__(self) -> None:
+        exe = _find_binary()
+        self._proc = subprocess.Popen(
+            [str(exe), "--server"],
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.DEVNULL,
+            text=True,
+            bufsize=1,
+        )
+        self._lock = threading.Lock()
+        self._next_id = 1
+        atexit.register(self.close)
+
+    def _request(self, method: str, **params: Any) -> Any:
+        with self._lock:
+            req_id = self._next_id
+            self._next_id += 1
+            payload = {"id": req_id, "method": method, **params}
+            assert self._proc.stdin is not None
+            assert self._proc.stdout is not None
+            self._proc.stdin.write(json.dumps(payload) + "\n")
+            self._proc.stdin.flush()
+            line = self._proc.stdout.readline()
+        resp = json.loads(line)
+        if "error" in resp:
+            raise RuntimeError(f"neml2-syntax error: {resp['error']}")
+        return resp["result"]
+
+    def list_sections(self) -> list[str]:
+        return self._request("list_sections")
+
+    def list_types(self, section: str = "") -> list[dict]:
+        return self._request("list_types", section=section)
+
+    def get_options(self, type_name: str) -> dict | None:
+        return self._request("get_options", type=type_name)
+
+    def close(self) -> None:
+        if self._proc.poll() is None:
+            self._proc.terminate()
+            try:
+                self._proc.wait(timeout=2)
+            except subprocess.TimeoutExpired:
+                self._proc.kill()
+
+
+_client: SyntaxClient | None = None
+
+
+def get_client() -> SyntaxClient | None:
+    if not _neml2_ok():
+        return None
+    global _client
+    if _client is None:
+        _client = SyntaxClient()
+    return _client

neml2_langserv-0.1.1/neml2_langserv.egg-info/PKG-INFO

@@ -0,0 +1,63 @@
+Metadata-Version: 2.4
+Name: neml2-langserv
+Version: 0.1.1
+Summary: Language server backing the NEML2 VS Code extension
+Project-URL: Homepage, https://github.com/applied-material-modeling/neml2-langserv
+Project-URL: Issues, https://github.com/applied-material-modeling/neml2-langserv/issues
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+Requires-Dist: pygls>=1.3
+Requires-Dist: neml2>=2.1.4
+Requires-Dist: nmhit>=0.1.2
+Provides-Extra: dev
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: build; extra == "dev"
+
+# NEML2 Language Support
+
+VS Code extension providing language support for [NEML2](https://github.com/applied-material-modeling/neml2) input files.
+
+## Features
+
+- **Completion** — type names for `type = ` assignments, and option names with inline type hints inside typed blocks
+- **Hover documentation** — docstrings for types and options shown on hover
+- **Format on save** — re-indents the document consistently via the `nmhit` formatter
+
+## Requirements
+
+A Python environment with the [`neml2-langserv`](https://pypi.org/project/neml2-langserv/) package installed:
+
+```
+pip install neml2-langserv
+```
+
+That single install pulls in everything the language server needs — [`neml2`](https://pypi.org/project/neml2/) (≥ 2.1.4) for the type/option metadata, [`nmhit`](https://pypi.org/project/nmhit/) (≥ 0.1.2) for the formatter, and `pygls` for the LSP transport.
+
+The extension runs the server with whichever Python interpreter is selected in the [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python). If `neml2-langserv` is not installed in that interpreter on first activation, the extension prompts you to install it.
+
+## Setup
+
+NEML2 input files share the `.i` extension with MOOSE input files. To tell the extension that a file is a NEML2 input, add the following as the **first line**:
+
+```
+# neml2
+```
+
+Files without this marker are treated as MOOSE input (or plain text) and the NEML2 language server will not activate for them.
+
+## Format on save
+
+Enable the built-in VS Code setting to auto-format on save:
+
+```jsonc
+// .vscode/settings.json
+{
+  "[neml2]": {
+    "editor.formatOnSave": true
+  }
+}
+```
+
+## MOOSE compatibility
+
+This extension does **not** claim the `.i` extension globally, so existing MOOSE workflows are unaffected. Only files whose first line matches `# neml2` (optionally followed by other text) are switched to the `neml2` language mode.

neml2_langserv-0.1.1/neml2_langserv.egg-info/SOURCES.txt

@@ -0,0 +1,12 @@
+README.md
+pyproject.toml
+neml2_langserv/__init__.py
+neml2_langserv/__main__.py
+neml2_langserv/hit_parser.py
+neml2_langserv/server.py
+neml2_langserv/syntax_client.py
+neml2_langserv.egg-info/PKG-INFO
+neml2_langserv.egg-info/SOURCES.txt
+neml2_langserv.egg-info/dependency_links.txt
+neml2_langserv.egg-info/requires.txt
+neml2_langserv.egg-info/top_level.txt

neml2_langserv-0.1.1/neml2_langserv.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

neml2_langserv-0.1.1/neml2_langserv.egg-info/requires.txt

@@ -0,0 +1,7 @@
+pygls>=1.3
+neml2>=2.1.4
+nmhit>=0.1.2
+
+[dev]
+pytest
+build

neml2_langserv-0.1.1/neml2_langserv.egg-info/top_level.txt

@@ -0,0 +1 @@
+neml2_langserv

neml2_langserv-0.1.1/pyproject.toml

@@ -0,0 +1,26 @@
+[build-system]
+requires = ["setuptools>=68"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "neml2-langserv"
+version = "0.1.1"
+description = "Language server backing the NEML2 VS Code extension"
+readme = "README.md"
+requires-python = ">=3.10"
+dependencies = [
+    "pygls>=1.3",
+    "neml2>=2.1.4",
+    "nmhit>=0.1.2",
+]
+
+[project.optional-dependencies]
+dev = ["pytest", "build"]
+
+[project.urls]
+Homepage = "https://github.com/applied-material-modeling/neml2-langserv"
+Issues = "https://github.com/applied-material-modeling/neml2-langserv/issues"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["neml2_langserv*"]

neml2_langserv-0.1.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+