dst-server 0.1.0__py3-none-any.whl

dst_server/__init__.py

@@ -0,0 +1,89 @@
+from __future__ import annotations
+
+from .arguments import ServerArgs
+from .cluster import Shard, ShardConfig, discover_shards, ensure_fifo, prepare_cluster
+from .events import (
+    DriverHealth,
+    EntityRef,
+    GameEvent,
+    ItemRef,
+    ObservedGameEvent,
+    ServerEvent,
+    ServerReadyEvent,
+    ServerSavedEvent,
+    ServerSessionEvent,
+    ServerShutdownEvent,
+    ServerStoppingEvent,
+    TelemetrySettings,
+    UnknownServerEvent,
+)
+from .game import GameClient
+from .models import (
+    Age,
+    Container,
+    Entity,
+    EquipmentSlot,
+    Health,
+    Inventory,
+    InventorySlot,
+    Item,
+    Mod,
+    Player,
+    PlayerState,
+    Position,
+    Room,
+    Runtime,
+    ShardStatus,
+    Stat,
+    Temperature,
+    Vitals,
+    World,
+)
+from .mods import prepare_mods, update_server_mods, workshop_mod_ids
+from .process import Server
+
+__all__ = [
+    "Age",
+    "Container",
+    "DriverHealth",
+    "Entity",
+    "EntityRef",
+    "EquipmentSlot",
+    "GameClient",
+    "GameEvent",
+    "Health",
+    "Inventory",
+    "InventorySlot",
+    "Item",
+    "ItemRef",
+    "Mod",
+    "ObservedGameEvent",
+    "Player",
+    "PlayerState",
+    "Position",
+    "Room",
+    "Runtime",
+    "Server",
+    "ServerArgs",
+    "ServerEvent",
+    "ServerReadyEvent",
+    "ServerSavedEvent",
+    "ServerSessionEvent",
+    "ServerShutdownEvent",
+    "ServerStoppingEvent",
+    "Shard",
+    "ShardConfig",
+    "ShardStatus",
+    "Stat",
+    "TelemetrySettings",
+    "Temperature",
+    "UnknownServerEvent",
+    "Vitals",
+    "World",
+    "discover_shards",
+    "ensure_fifo",
+    "prepare_cluster",
+    "prepare_mods",
+    "update_server_mods",
+    "workshop_mod_ids",
+]

dst_server/_fd_wrapper.py

@@ -0,0 +1,24 @@
+from __future__ import annotations
+
+import os
+import sys
+
+_PROTOCOL_FDS = (3, 4, 5)
+
+
+def main() -> None:
+    sources = tuple(int(value) for value in sys.argv[1:4])
+    command = sys.argv[4:]
+    if len(sources) != len(_PROTOCOL_FDS) or not command:
+        msg = "usage: _fd_wrapper.py FD3 FD4 FD5 COMMAND [ARG ...]"
+        raise SystemExit(msg)
+    for source, target in zip(sources, _PROTOCOL_FDS, strict=True):
+        os.dup2(source, target, inheritable=True)
+    for source in sources:
+        if source not in _PROTOCOL_FDS:
+            os.close(source)
+    os.execv(command[0], command)  # ruff:ignore[start-process-with-no-shell]
+
+
+if __name__ == "__main__":
+    main()

dst_server/annotations/__init__.py

@@ -0,0 +1,5 @@
+from __future__ import annotations
+
+from .generator import generate_components, generate_modutil
+
+__all__ = ["generate_components", "generate_modutil"]

dst_server/annotations/cli.py

@@ -0,0 +1,80 @@
+from __future__ import annotations
+
+import argparse
+import logging
+from collections.abc import Sequence
+from pathlib import Path
+
+from .generator import generate_components, generate_modutil
+
+logger = logging.getLogger(__name__)
+
+
+def create_parser() -> argparse.ArgumentParser:
+    parser = argparse.ArgumentParser(
+        description="Generate LSP-compatible Lua annotations."
+    )
+    parser.add_argument("input", type=Path, help="Components directory or modutil file")
+    parser.add_argument("-o", "--output", type=Path, help="Output Lua file")
+    parser.add_argument("-m", "--max-workers", type=int, help="Worker process count")
+    parser.add_argument(
+        "--mode",
+        choices=("auto", "components", "modutil"),
+        default="auto",
+    )
+    return parser
+
+
+def resolve_mode(
+    parser: argparse.ArgumentParser,
+    input_path: Path,
+    requested: str,
+) -> str:
+    if requested != "auto":
+        return requested
+    if input_path.is_dir():
+        return "components"
+    if input_path.is_file() and "modutil" in input_path.name.lower():
+        return "modutil"
+    return parser.error("Cannot infer mode; pass --mode explicitly.")
+
+
+def write_components(input_path: Path, output: Path | None, workers: int | None) -> int:
+    content = generate_components(input_path, workers)
+    if not content:
+        logger.error("No Lua component definitions generated from %s", input_path)
+        return 1
+
+    output_path = output or Path(f"{input_path.name}_def.lua")
+    output_path.write_text(content, encoding="utf-8")
+    logger.info("Output written to %s", output_path)
+    return 0
+
+
+def write_modutil(input_path: Path, output: Path | None) -> int:
+    if not input_path.is_file():
+        raise FileNotFoundError(input_path)
+
+    content = generate_modutil(input_path)
+    if not content:
+        logger.error("No definitions found in %s", input_path)
+        return 1
+
+    output_path = output or Path(f"{input_path.stem}_def.lua")
+    output_path.write_text(content, encoding="utf-8")
+    logger.info("Output written to %s", output_path)
+    return 0
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    logging.basicConfig(level=logging.INFO, format="%(message)s")
+    parser = create_parser()
+    args = parser.parse_args(argv)
+    mode = resolve_mode(parser, args.input, args.mode)
+
+    try:
+        if mode == "components":
+            return write_components(args.input, args.output, args.max_workers)
+        return write_modutil(args.input, args.output)
+    except Exception as error:
+        parser.error(str(error))

dst_server/annotations/generator.py

@@ -0,0 +1,66 @@
+from __future__ import annotations
+
+import logging
+from concurrent.futures import ProcessPoolExecutor
+from itertools import repeat
+from pathlib import Path
+
+from .visitors import DEFAULT_VAR, parse_component, parse_modutil
+
+logger = logging.getLogger(__name__)
+
+
+def extract_class_name(content: str) -> str | None:
+    for source_line in reversed(content.splitlines()):
+        line = source_line.strip()
+        if line.startswith("return "):
+            return line.removeprefix("return ").split(maxsplit=1)[0].rstrip(",")
+    return None
+
+
+def component_definition(path: Path, folder_name: str) -> tuple[str, str] | None:
+    try:
+        content = path.read_text(encoding="utf-8")
+        class_name = extract_class_name(content) or path.stem
+        fields, definitions = parse_component(
+            content,
+            path.stem,
+            class_name,
+            folder_name,
+        )
+    except Exception as error:
+        logger.warning("Could not parse %s: %s", path, error)
+        return None
+
+    lines = [f"---@class {class_name}", *fields]
+    lines.extend((
+        f"local {DEFAULT_VAR}={{}}",
+        f"{folder_name}.{path.stem}={DEFAULT_VAR}",
+        "",
+        *definitions,
+        "",
+    ))
+    return path.stem, "\n".join(lines)
+
+
+def generate_components(input_dir: Path, max_workers: int | None = None) -> str:
+    if not input_dir.is_dir():
+        raise NotADirectoryError(input_dir)
+
+    files = sorted(input_dir.rglob("*.lua"))
+    if max_workers == 1:
+        results = [component_definition(path, input_dir.name) for path in files]
+    else:
+        with ProcessPoolExecutor(max_workers=max_workers) as executor:
+            results = list(
+                executor.map(component_definition, files, repeat(input_dir.name))
+            )
+
+    definitions = sorted(result for result in results if result is not None)
+    return "\n".join(content for _, content in definitions)
+
+
+def generate_modutil(input_file: Path) -> str:
+    content = input_file.read_text(encoding="utf-8")
+    definitions = parse_modutil(content, input_file.stem)
+    return "\n".join(definitions) + ("\n" if definitions else "")

dst_server/annotations/values.py

@@ -0,0 +1,82 @@
+from __future__ import annotations
+
+from enum import StrEnum
+from typing import Any
+
+from luaparser import ast
+
+
+class LuaType(StrEnum):
+    STRING = "string"
+    NUMBER = "number"
+    BOOLEAN = "boolean"
+    TABLE = "table"
+    NIL = "nil"
+    FUNCTION = "function"
+    USERDATA = "userdata"
+    ANY = "any"
+
+
+DEFAULT_VALUES = {
+    LuaType.TABLE: "{}",
+    LuaType.NUMBER: "0",
+    LuaType.FUNCTION: "function()end",
+    LuaType.USERDATA: "newproxy()",
+    LuaType.STRING: '""',
+    LuaType.NIL: "nil",
+    LuaType.ANY: "variable",
+}
+
+
+def infer_type(node: Any) -> LuaType:
+    match node:
+        case ast.String() | ast.Concat():
+            return LuaType.STRING
+        case (
+            ast.Number()
+            | ast.AddOp()
+            | ast.SubOp()
+            | ast.MultOp()
+            | ast.FloatDivOp()
+            | ast.FloorDivOp()
+        ):
+            return LuaType.NUMBER
+        case ast.TrueExpr() | ast.FalseExpr():
+            return LuaType.BOOLEAN
+        case ast.Table():
+            return LuaType.TABLE
+        case ast.Nil():
+            return LuaType.NIL
+        case ast.Function():
+            return LuaType.FUNCTION
+        case ast.Call(func=ast.Name(id="newproxy")):
+            return LuaType.USERDATA
+        case _:
+            return LuaType.ANY
+
+
+def construct_value(
+    lua_type: LuaType | list[LuaType] | None,
+    source: str | None = None,
+) -> str:
+    if lua_type is None:
+        return "variable"
+
+    if isinstance(lua_type, list):
+        values = source.split(",") if source else []
+        return ",".join(
+            construct_value(
+                item_type,
+                values[index].strip() if index < len(values) else None,
+            )
+            for index, item_type in enumerate(lua_type)
+        )
+
+    if lua_type == LuaType.BOOLEAN:
+        value = source.strip() if source else None
+        return value if value in {"true", "false"} else "false"
+
+    if source and source.strip() == "inst":
+        return "inst"
+
+    return DEFAULT_VALUES.get(lua_type, "variable")

dst_server/annotations/visitors.py

@@ -0,0 +1,252 @@
+from __future__ import annotations
+
+from typing import Any
+
+from luaparser import ast
+
+from .values import LuaType, construct_value, infer_type
+
+type ReturnInfo = tuple[list[LuaType], str]
+
+BANNED_NAMES = ("inst", "GetDebugString")
+DEFAULT_VAR = "_l"
+
+
+def argument_names(arguments: Any) -> list[str]:
+    names = []
+    for argument in arguments:
+        name = getattr(argument, "id", None)
+        if isinstance(name, str):
+            names.append(name)
+        elif type(argument).__name__ == "Varargs":
+            names.append("...")
+        else:
+            names.append("arg")
+    return names
+
+
+def indexed_name(node: Any, owner: str) -> str | None:
+    if not isinstance(node, ast.Index):
+        return None
+    if not isinstance(node.value, ast.Name) or node.value.id != owner:
+        return None
+    return node.idx.id if isinstance(node.idx, ast.Name) else None
+
+
+def method_name(node: Any, owner: str) -> str | None:
+    if not isinstance(node.source, ast.Name) or node.source.id != owner:
+        return None
+    return node.name.id if isinstance(node.name, ast.Name) else None
+
+
+def anonymous_function(node: Any) -> Any | None:
+    values = getattr(node, "values", ())
+    if not values or not isinstance(values[0], ast.AnonymousFunction):
+        return None
+    return values[0]
+
+
+def pretty_value(node: Any) -> str:
+    try:
+        return ast.to_pretty_str(node)
+    except Exception:
+        return "variable"
+
+
+class ReturnVisitor(ast.ASTVisitor):
+    def __init__(self) -> None:
+        self.returns: list[ReturnInfo] = []
+
+    def visit_Return(self, node: Any) -> bool:
+        values = getattr(node, "values", ())
+        self.returns.append((
+            [infer_type(value) for value in values],
+            ", ".join(pretty_value(value) for value in values),
+        ))
+        return False
+
+
+def return_info(body: Any) -> list[ReturnInfo]:
+    visitor = ReturnVisitor()
+    visitor.visit(body)
+    return visitor.returns
+
+
+class BaseVisitor(ast.ASTVisitor):
+    def __init__(self, filename: str, local_var: str) -> None:
+        self.filename = filename
+        self.local_var = local_var
+        self.processed = set[str]()
+
+    def build_annotations(
+        self,
+        parameters: list[str],
+        returns: list[ReturnInfo],
+        node: Any,
+        source_prefix: str = "",
+    ) -> list[str]:
+        token = getattr(node, "first_token", None)
+        line = getattr(token, "line", "unknown")
+        annotations = [f"---@source {source_prefix}{self.filename}.lua:{line}"]
+
+        for parameter in parameters:
+            if parameter == "...":
+                annotations.append("---@param ... any")
+            elif parameter != "self":
+                annotations.append(f"---@param {parameter} any")
+
+        if returns and returns[-1][0]:
+            annotations.append(f"---@return {', '.join(returns[-1][0])}")
+
+        return annotations
+
+    def build_function(
+        self,
+        name: str,
+        parameters: list[str],
+        returns: list[ReturnInfo],
+        node: Any,
+        source_prefix: str = "",
+    ) -> str:
+        lines = self.build_annotations(parameters, returns, node, source_prefix)
+        function = f"function {name}({', '.join(parameters)})"
+
+        if returns:
+            return_types, return_source = returns[-1]
+            value = construct_value(return_types, return_source)
+            lines.append(f"{function} return {value} end")
+        else:
+            lines.append(f"{function} end")
+
+        return "\n".join(lines)
+
+
+class ComponentVisitor(BaseVisitor):
+    def __init__(
+        self,
+        filename: str,
+        class_name: str,
+        folder_name: str,
+        local_var: str = DEFAULT_VAR,
+    ) -> None:
+        super().__init__(filename, local_var)
+        self.class_name = class_name
+        self.folder_name = folder_name
+        self.methods: list[str] = []
+        self.fields: dict[str, tuple[LuaType | None, str | None]] = {}
+
+    def visit_Method(self, node: Any) -> bool:
+        name = method_name(node, self.class_name)
+        if name is None or name in BANNED_NAMES or name in self.processed:
+            return False
+
+        self.processed.add(name)
+        self.methods.append(
+            self.build_function(
+                f"{self.local_var}:{name}",
+                argument_names(node.args),
+                return_info(node.body),
+                node,
+                source_prefix=f"{self.folder_name}/",
+            )
+        )
+        return False
+
+    def visit_Assign(self, node: Any) -> None:
+        function = anonymous_function(node)
+        for target in node.targets:
+            if name := indexed_name(target, "self"):
+                self.record_field(name, node)
+                continue
+
+            if function is not None and (name := indexed_name(target, self.class_name)):
+                self.record_function(name, function)
+
+    def record_field(self, name: str, node: Any) -> None:
+        if name in BANNED_NAMES or name in self.processed:
+            return
+
+        value_type = None
+        value_source = None
+        if node.values:
+            value = node.values[0]
+            value_type = infer_type(value)
+            value_source = (
+                "function() end"
+                if isinstance(value, (ast.Function, ast.Method, ast.AnonymousFunction))
+                else pretty_value(value)
+            )
+
+        current = self.fields.get(name)
+        if current is None or current[0] in {None, LuaType.ANY}:
+            self.fields[name] = value_type, value_source
+
+    def record_function(self, name: str, node: Any) -> None:
+        if name in BANNED_NAMES or name in self.processed:
+            return
+
+        self.processed.add(name)
+        self.methods.append(
+            self.build_function(
+                name,
+                argument_names(node.args),
+                return_info(node.body),
+                node,
+                source_prefix=f"{self.folder_name}/",
+            )
+        )
+
+    def definitions(self) -> tuple[list[str], list[str]]:
+        fields = sorted(self.fields.items())
+        annotations = [
+            f"---@field {name} {value_type or 'any'}"
+            for name, (value_type, _) in fields
+        ]
+        values = [
+            f"{self.local_var}.{name}={construct_value(value_type, source)}"
+            for name, (value_type, source) in fields
+        ]
+        return annotations, [*self.methods, *values]
+
+
+class ModutilVisitor(BaseVisitor):
+    def __init__(self, filename: str) -> None:
+        super().__init__(filename, "_m")
+        self.functions: list[str] = []
+
+    def visit_Assign(self, node: Any) -> None:
+        function = anonymous_function(node)
+        if function is None:
+            return
+
+        for target in node.targets:
+            name = indexed_name(target, "env")
+            if name is None or name in self.processed:
+                continue
+
+            self.processed.add(name)
+            self.functions.append(
+                self.build_function(
+                    name,
+                    argument_names(function.args),
+                    return_info(function.body),
+                    function,
+                )
+            )
+
+
+def parse_component(
+    content: str,
+    filename: str,
+    class_name: str,
+    folder_name: str,
+) -> tuple[list[str], list[str]]:
+    visitor = ComponentVisitor(filename, class_name, folder_name)
+    visitor.visit(ast.parse(content))
+    return visitor.definitions()
+
+
+def parse_modutil(content: str, filename: str) -> list[str]:
+    visitor = ModutilVisitor(filename)
+    visitor.visit(ast.parse(content))
+    return visitor.functions

dst_server/arguments.py

@@ -0,0 +1,47 @@
+from __future__ import annotations
+
+from dataclasses import dataclass, field
+from pathlib import Path
+
+from .events import TelemetrySettings
+
+LUA_DIRECTORY = Path(__file__).with_name("lua")
+
+
+@dataclass(frozen=True, slots=True)
+class ServerArgs:
+    shard: str
+    executable: Path = Path(
+        "/install/bin64/dontstarve_dedicated_server_nullrenderer_x64"
+    )
+    persistent_storage_root: Path = Path("/")
+    conf_dir: str = "/"
+    cluster: str = "cluster"
+    ugc_directory: Path | None = Path("/cluster/mods/ugc")
+    extra: tuple[str, ...] = ("-skip_update_server_mods",)
+    lua_directory: Path = LUA_DIRECTORY
+    telemetry: TelemetrySettings = field(default_factory=TelemetrySettings)
+    monitor_parent_process: bool = True
+
+    def command(self, *, monitor_parent_process: int | None = None) -> tuple[str, ...]:
+        command = [
+            str(self.executable),
+            "-persistent_storage_root",
+            str(self.persistent_storage_root),
+            "-conf_dir",
+            self.conf_dir,
+            "-cluster",
+            self.cluster,
+            "-shard",
+            self.shard,
+        ]
+        if self.ugc_directory is not None:
+            command.extend(("-ugc_directory", str(self.ugc_directory)))
+        if monitor_parent_process is not None:
+            command.extend(("-monitor_parent_process", str(monitor_parent_process)))
+        command.extend(self.extra)
+        command.append("-cloudserver")
+        return tuple(command)
+
+
+__all__ = ["ServerArgs"]