dna-builder-sdk 0.1.0__py3-none-any.whl

dna_builder_sdk/__init__.py

@@ -0,0 +1,27 @@
+"""dna-builder Python SDK：自建后端公开读接口 + 数据双加载 + 纯表达式计算。"""
+
+from .backend import BackendClient
+from .calc.gamedata import TableSource, resolve_tables
+from .data_pack import DataPackStore, revive_packed_value
+from .errors import DobApiError, DobGraphQLError, DobHttpError
+from .game_data import GameDataClient
+from .module_store import ModuleStore
+from .snapshots import BuildSnapshot, snapshot_from_online, snapshot_from_settings
+
+__all__ = [
+    "BackendClient",
+    "GameDataClient",
+    "DataPackStore",
+    "ModuleStore",
+    "TableSource",
+    "BuildSnapshot",
+    "resolve_tables",
+    "snapshot_from_online",
+    "snapshot_from_settings",
+    "revive_packed_value",
+    "DobApiError",
+    "DobHttpError",
+    "DobGraphQLError",
+]
+
+__version__ = "0.1.0"

dna_builder_sdk/backend.py

@@ -0,0 +1,202 @@
+"""自建后端（Elysia）传输层 + 公开读接口。
+
+只覆盖无需登录的 Query：评论 / 构筑 / 攻略 / 时间轴 / 榜单 / 脚本 /
+MOD / DPS / gameData*。Mutation、admin、shop 私有、my* 一律不实现。
+标准库 urllib 实现零额外 HTTP 依赖，302 默认跟随。
+"""
+
+from __future__ import annotations
+
+import json
+import urllib.error
+import urllib.parse
+import urllib.request
+
+from .errors import DobGraphQLError, DobHttpError
+
+_DEFAULT_TIMEOUT = 30
+
+
+def _post_json(url: str, payload: dict, timeout: float) -> tuple[int, dict | list, str]:
+    """POST JSON 并返回 (status, body, final_url)，302 由 opener 自动跟随。"""
+    data = json.dumps(payload).encode("utf-8")
+    req = urllib.request.Request(
+        url,
+        data=data,
+        headers={"content-type": "application/json", "accept": "application/json"},
+        method="POST",
+    )
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.status, json.loads(resp.read().decode("utf-8")), resp.geturl()
+    except urllib.error.HTTPError as exc:
+        try:
+            body = json.loads(exc.read().decode("utf-8"))
+        except Exception:
+            body = {"message": str(exc)}
+        raise DobHttpError(f"HTTP {exc.code}: {url}", status=exc.code, payload=body) from exc
+    except urllib.error.URLError as exc:
+        raise DobHttpError(f"连接失败: {url} ({exc.reason})", status=0) from exc
+
+
+def _get_json(url: str, timeout: float):
+    req = urllib.request.Request(url, headers={"accept": "application/json"}, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return json.loads(resp.read().decode("utf-8"))
+    except urllib.error.HTTPError as exc:
+        raise DobHttpError(f"HTTP {exc.code}: {url}", status=exc.code) from exc
+    except urllib.error.URLError as exc:
+        raise DobHttpError(f"连接失败: {url} ({exc.reason})", status=0) from exc
+
+
+class BackendClient:
+    """自建后端客户端，默认线上端点；本地联调传 http://localhost:8887。"""
+
+    def __init__(self, base_url: str = "https://api.dna-builder.cn", timeout: float = _DEFAULT_TIMEOUT):
+        self.base_url = base_url.rstrip("/")
+        self.timeout = timeout
+
+    @property
+    def graphql_url(self) -> str:
+        return f"{self.base_url}/graphql"
+
+    def graphql(self, query: str, variables: dict | None = None) -> dict:
+        """裸 GraphQL 调用，errors 非空时抛 DobGraphQLError。"""
+        _, body, _ = _post_json(self.graphql_url, {"query": query, "variables": variables or {}}, self.timeout)
+        if not isinstance(body, dict):
+            raise DobGraphQLError(f"网关返回非对象: {body!r}", errors=[body])
+        if body.get("errors"):
+            first = body["errors"][0]
+            msg = first.get("message", "graphql error") if isinstance(first, dict) else str(first)
+            raise DobGraphQLError(msg, errors=body["errors"])
+        return body.get("data") or {}
+
+    # ---- 评论（读） ----
+    def comments(self, target_id: str, limit: int = 50, offset: int = 0) -> list:
+        data = self.graphql(
+            "query($t:String!,$l:Int,$o:Int){comments(targetId:$t,limit:$l,offset:$o){id targetId content createdAt user{id name}}}",
+            {"t": target_id, "l": limit, "o": offset},
+        )
+        return data.get("comments") or []
+
+    def comments_count(self, target_id: str) -> int:
+        data = self.graphql("query($t:String!){commentsCount(targetId:$t)}", {"t": target_id})
+        return int(data.get("commentsCount") or 0)
+
+    # ---- 构筑（读） ----
+    def builds(self, search=None, char_id=None, user_id=None, limit=20, offset=0, sort_by="latest") -> list:
+        data = self.graphql(
+            "query($s:String,$c:Int,$u:String,$l:Int,$o:Int,$sb:String)"
+            "{builds(search:$s,charId:$c,userId:$u,limit:$l,offset:$o,sortBy:$sb)"
+            "{id title desc charId userId views likes isRecommended isPinned createdAt updateAt targetValue charSettings}}",
+            {"s": search, "c": char_id, "u": user_id, "l": limit, "o": offset, "sb": sort_by},
+        )
+        return data.get("builds") or []
+
+    def builds_count(self, search=None, char_id=None) -> int:
+        data = self.graphql(
+            "query($s:String,$c:Int){buildsCount(search:$s,charId:$c)}", {"s": search, "c": char_id}
+        )
+        return int(data.get("buildsCount") or 0)
+
+    def build(self, build_id: str) -> dict | None:
+        data = self.graphql(
+            "query($id:String!){build(id:$id){id title desc charId charSettings userId views likes createdAt updateAt targetValue}}",
+            {"id": build_id},
+        )
+        return data.get("build")
+
+    def recommended_builds(self, limit=10) -> list:
+        return (self.graphql("query($l:Int){recommendedBuilds(limit:$l){id title charId likes views}}", {"l": limit}).get("recommendedBuilds") or [])
+
+    def trending_builds(self, limit=10) -> list:
+        return (self.graphql("query($l:Int){trendingBuilds(limit:$l){id title charId likes views}}", {"l": limit}).get("trendingBuilds") or [])
+
+    # ---- 攻略（读） ----
+    def guides(self, search=None, type=None, char_id=None, user_id=None, limit=20, offset=0) -> list:
+        data = self.graphql(
+            "query($s:String,$t:String,$c:Int,$u:String,$l:Int,$o:Int)"
+            "{guides(search:$s,type:$t,charId:$c,userId:$u,limit:$l,offset:$o){id title type charId views likes createdAt updateAt}}",
+            {"s": search, "t": type, "c": char_id, "u": user_id, "l": limit, "o": offset},
+        )
+        return data.get("guides") or []
+
+    def guide(self, guide_id: str) -> dict | None:
+        data = self.graphql(
+            "query($id:String!){guide(id:$id){id title type content images charId buildId views likes createdAt updateAt}}",
+            {"id": guide_id},
+        )
+        return data.get("guide")
+
+    # ---- 时间轴（读） ----
+    def timelines(self, search=None, char_id=None, user_id=None, limit=20, offset=0, sort_by="recent") -> list:
+        data = self.graphql(
+            "query($s:String,$c:Int,$u:String,$l:Int,$o:Int,$sb:String)"
+            "{timelines(search:$s,charId:$c,userId:$u,limit:$l,offset:$o,sortBy:$sb){id title charId views likes createdAt updateAt}}",
+            {"s": search, "c": char_id, "u": user_id, "l": limit, "o": offset, "sb": sort_by},
+        )
+        return data.get("timelines") or []
+
+    def timeline(self, timeline_id: str) -> dict | None:
+        data = self.graphql(
+            "query($id:String!){timeline(id:$id){id title charId views likes createdAt updateAt}}",
+            {"id": timeline_id},
+        )
+        return data.get("timeline")
+
+    # ---- 榜单（读） ----
+    def ranking_lists(self) -> list:
+        return (self.graphql("{rankingLists{id name desc createdAt updateAt}}").get("rankingLists") or [])
+
+    def ranking_list(self, list_id: str) -> dict | None:
+        data = self.graphql(
+            "query($id:String!){rankingList(id:$id){id name desc items{id charId buildId sortOrder}}}",
+            {"id": list_id},
+        )
+        return data.get("rankingList")
+
+    def ranking_list_items(self, ranking_list_id: str) -> list:
+        data = self.graphql(
+            "query($id:String!){rankingListItems(rankingListId:$id){id charId buildId sortOrder}}",
+            {"id": ranking_list_id},
+        )
+        return data.get("rankingListItems") or []
+
+    # ---- 脚本 / MOD / DPS（读） ----
+    def scripts(self, search=None, category=None, user_id=None, limit=20, offset=0) -> list:
+        data = self.graphql(
+            "query($s:String,$c:String,$u:String,$l:Int,$o:Int)"
+            "{scripts(search:$s,category:$c,userId:$u,limit:$l,offset:$o){id title category createdAt updateAt}}",
+            {"s": search, "c": category, "u": user_id, "l": limit, "o": offset},
+        )
+        return data.get("scripts") or []
+
+    def script(self, script_id: str, preview: bool = False) -> dict | None:
+        data = self.graphql(
+            "query($id:String!,$p:Boolean){script(id:$id,preview:$p){id title category content}}",
+            {"id": script_id, "p": preview},
+        )
+        return data.get("script")
+
+    def game_mods(self, search=None, category=None, entity=None, limit=20, offset=0, sort_by=None) -> list:
+        data = self.graphql(
+            "query($s:String,$c:String,$e:String,$l:Int,$o:Int,$sb:String)"
+            "{gameMods(search:$s,category:$c,entity:$e,limit:$l,offset:$o,sortBy:$sb){id title category entity status createdAt updateAt}}",
+            {"s": search, "c": category, "e": entity, "l": limit, "o": offset, "sb": sort_by},
+        )
+        return data.get("gameMods") or []
+
+    def game_mod(self, mod_id: str) -> dict | None:
+        data = self.graphql(
+            "query($id:String!){gameMod(id:$id){id title category entity status}}", {"id": mod_id}
+        )
+        return data.get("gameMod")
+
+    def dps_list(self, char_id=None, build_id=None, timeline_id=None, limit=20, offset=0, sort_by="dpsValue") -> list:
+        data = self.graphql(
+            "query($c:Int,$b:String,$t:String,$l:Int,$o:Int,$sb:String)"
+            "{dpsList(charId:$c,buildId:$b,timelineId:$t,limit:$l,offset:$o,sortBy:$sb){id charId buildId dpsValue createdAt}}",
+            {"c": char_id, "b": build_id, "t": timeline_id, "l": limit, "o": offset, "sb": sort_by},
+        )
+        return data.get("dpsList") or []

dna_builder_sdk/calc/__init__.py

@@ -0,0 +1,13 @@
+"""calc 包：BD 装配 + 聚合引擎 + 表达式/伤害结算（无编辑语义）。"""
+
+from .ast import AstError, parse_ast, tokenize_ast
+from .build import build_state, parse_trace_levels
+from .damage import DamageContext
+from .engine import Engine
+from .evaluate import evaluate
+from .gamedata import GameDataTables, TableSource, resolve_tables
+
+__all__ = [
+    "AstError", "DamageContext", "Engine", "GameDataTables", "TableSource",
+    "build_state", "parse_trace_levels", "parse_ast", "tokenize_ast", "evaluate", "resolve_tables",
+]

dna_builder_sdk/calc/ast.py

@@ -0,0 +1,254 @@
+"""AST 词法/语法：逐行对齐 src/data/ast.ts（Tokenizer + Parser）。
+
+节点为普通 dict，type 取值：binary / unary / property / function /
+member_access / temporary_attributes / number，与 TS 字段名一致
+（含 namespace / forceAttr / skillContext 占位，后者 SDK 不绑定）。
+"""
+
+from __future__ import annotations
+
+
+class AstError(ValueError):
+    pass
+
+
+class _Tokenizer:
+    def __init__(self, text: str, macros: dict[str, str]):
+        self.text = text
+        self.pos = 0
+        self.macros = macros
+
+    def next_token(self):
+        self._skip_ws()
+        if self.pos >= len(self.text):
+            return {"kind": "EOF", "value": "", "pos": self.pos}
+        ch = self.text[self.pos]
+        if ch.isdigit():
+            start = self.pos
+            buf = ""
+            while self.pos < len(self.text) and (self.text[self.pos].isdigit() or self.text[self.pos] == "."):
+                buf += self.text[self.pos]
+                self.pos += 1
+            return {"kind": "NUMBER", "value": buf, "pos": start}
+        if ch.isalpha() or ch == "_" or ch == "[" or "\u4e00" <= ch <= "\u9fa5" or ch == "·":
+            start = self.pos
+            buf = ""
+            while self.pos < len(self.text):
+                c = self.text[self.pos]
+                if c.isalnum() or c == "_" or "\u4e00" <= c <= "\u9fa5" or c in ("·", "[", "]"):
+                    buf += c
+                    self.pos += 1
+                else:
+                    break
+            if buf in self.macros:
+                repl = self.macros[buf]
+                self.text = self.text[: start] + repl + self.text[self.pos :]
+                self.pos = start
+                return self.next_token()
+            return {"kind": "IDENT", "value": buf, "pos": start}
+        if ch == "/" and self.pos + 1 < len(self.text) and self.text[self.pos + 1] == "/":
+            self.pos += 2
+            return {"kind": "OP", "value": "//", "pos": self.pos - 2}
+        if ch in ("+", "-", "*", "/", "%"):
+            self.pos += 1
+            return {"kind": "OP", "value": ch, "pos": self.pos - 1}
+        if ch == ".":
+            self.pos += 1
+            return {"kind": "DOT", "value": ".", "pos": self.pos - 1}
+        if ch == ":":
+            if self.pos + 1 < len(self.text) and self.text[self.pos + 1] == ":":
+                self.pos += 2
+                return {"kind": "DCOLON", "value": "::", "pos": self.pos - 2}
+            self.pos += 1
+            return {"kind": "COLON", "value": ":", "pos": self.pos - 1}
+        simple = {"(": "LPAREN", ")": "RPAREN", ",": "COMMA", "{": "LBRACE", "}": "RBRACE", "!": "BANG"}
+        if ch in simple:
+            self.pos += 1
+            return {"kind": simple[ch], "value": ch, "pos": self.pos - 1}
+        raise AstError(f"未知字符 '{ch}' 位于位置 {self.pos}")
+
+    def _skip_ws(self):
+        while self.pos < len(self.text) and self.text[self.pos].isspace():
+            self.pos += 1
+
+
+class _Parser:
+    def __init__(self, text: str, macros: dict[str, str]):
+        tok = _Tokenizer(text, macros)
+        self.tokens: list[dict] = []
+        while True:
+            t = tok.next_token()
+            if t["kind"] == "EOF":
+                break
+            self.tokens.append(t)
+        self.cur = 0
+
+    def parse(self):
+        if not self.tokens:
+            raise AstError("表达式为空")
+        node = self._expr()
+        if self.cur < len(self.tokens):
+            if self._peek()["kind"] == "COLON":
+                raise AstError("单个冒号 ':' 不支持,请使用 '::' 进行命名空间访问")
+            raise AstError(f"表达式末尾发现意外的标记 '{self._peek()['value']}'")
+        return node
+
+    def _expr(self):
+        left = self._term()
+        while self._match("OP", "+") or self._match("OP", "-"):
+            op = self._prev()["value"]
+            if self._at_end() or self._check("OP") or self._check("RPAREN") or self._check("COMMA"):
+                raise AstError(f"运算符 '{op}' 后缺少操作数")
+            left = {"type": "binary", "operator": op, "left": left, "right": self._term()}
+        return left
+
+    def _term(self):
+        left = self._unary()
+        while (
+            self._match("OP", "*") or self._match("OP", "/") or self._match("OP", "//") or self._match("OP", "%")
+        ):
+            op = self._prev()["value"]
+            if self._at_end() or self._check("OP") or self._check("RPAREN") or self._check("COMMA"):
+                raise AstError(f"运算符 '{op}' 后缺少操作数")
+            left = {"type": "binary", "operator": op, "left": left, "right": self._unary()}
+        return left
+
+    def _unary(self):
+        if self._match("OP", "-") or self._match("OP", "+"):
+            return {"type": "unary", "operator": self._prev()["value"], "argument": self._unary()}
+        return self._factor()
+
+    def _factor(self):
+        if self._match("NUMBER"):
+            node: dict = {"type": "number", "value": float(self._prev()["value"])}
+        elif self._match("IDENT"):
+            name = self._prev()["value"]
+            ns = None
+            if self._match("DCOLON"):
+                ns = name
+                nxt = self._consume("IDENT", "命名空间 '::' 后缺少标识符")
+                name = nxt["value"]
+                if self._match("LPAREN"):
+                    node = {"type": "function", "name": name, "namespace": ns, "args": self._arg_list()}
+                else:
+                    node = {"type": "property", "name": name, "namespace": ns}
+                    node = self._force_suffix(node)
+            elif self._match("LPAREN"):
+                node = {"type": "function", "name": name, "args": self._arg_list()}
+            else:
+                node = {"type": "property", "name": name}
+                node = self._force_suffix(node)
+        elif self._match("LPAREN"):
+            node = self._expr()
+            self._consume("RPAREN", "表达式后缺少 ')'")
+        else:
+            raise AstError(f"意外的标记: {self._peek()['value']}")
+        while True:
+            if self._match("DOT"):
+                prop = self._consume("IDENT", "成员访问 '.' 后缺少属性名称")
+                node = {"type": "member_access", "object": node, "property": prop["value"]}
+                continue
+            if self._match("LBRACE"):
+                if node["type"] not in ("property", "member_access", "temporary_attributes"):
+                    raise AstError("临时属性只能应用于字段")
+                attrs: list[dict] = []
+                seen: set[str] = set()
+                if self._check("RBRACE"):
+                    raise AstError("临时属性不能为空")
+                while True:
+                    a = self._consume("IDENT", "临时属性缺少属性名")
+                    self._consume("COLON", f"临时属性 '{a['value']}' 后缺少 ':'")
+                    if a["value"] in seen:
+                        raise AstError(f"临时属性 '{a['value']}' 重复")
+                    seen.add(a["value"])
+                    attrs.append({"name": a["value"], "value": self._expr()})
+                    if not self._match("COMMA"):
+                        break
+                self._consume("RBRACE", "临时属性后缺少 '}'")
+                node = {"type": "temporary_attributes", "target": node, "attributes": attrs}
+                continue
+            break
+        return node
+
+    def _arg_list(self):
+        args = []
+        if not self._check("RPAREN"):
+            while True:
+                args.append(self._expr())
+                if not self._match("COMMA"):
+                    break
+        self._consume("RPAREN", "函数参数后缺少 ')'")
+        return args
+
+    def _force_suffix(self, node):
+        if self._match("BANG"):
+            node = {**node, "forceAttr": True}
+        return node
+
+    # -- 游标 --
+    def _match(self, kind, value=None):
+        if self._check(kind, value):
+            self.cur += 1
+            return True
+        return False
+
+    def _check(self, kind, value=None):
+        if self._at_end():
+            return False
+        t = self._peek()
+        if t["kind"] != kind:
+            return False
+        return value is None or t["value"] == value
+
+    def _at_end(self):
+        return self.cur >= len(self.tokens)
+
+    def _peek(self):
+        return self.tokens[self.cur] if self.cur < len(self.tokens) else {"kind": "EOF", "value": ""}
+
+    def _prev(self):
+        return self.tokens[self.cur - 1]
+
+    def _consume(self, kind, message):
+        if self._check(kind):
+            self.cur += 1
+            return self._prev()
+        raise AstError(message)
+
+
+def _normalize_macros(macros) -> dict[str, str]:
+    if not macros:
+        return {}
+    if isinstance(macros, dict):
+        return dict(macros)
+    raise AstError("macros 仅支持 dict（TS 侧 Map/Record 口径）")
+
+
+# CharBuild.macros：AST 表达式宏替换（TS 侧每次 parseAST 传入）
+CHAR_MACROS = {
+    "ATK": "攻击", "DEF": "防御", "HP": "生命", "SP": "神智",
+    "DPH": "or(多重,1)*伤害", "总伤": "max(1,召唤物攻击次数)*伤害",
+    "暴击伤害": "伤害.暴击", "DPS": "or(攻速,1+技能速度)*or(多重,1)*伤害",
+    "范围收益": "技能范围*伤害", "耐久收益": "技能耐久*伤害", "效益收益": "技能效益*伤害",
+    "每神智DPH": "1/神智消耗*伤害", "每持续神智DPH": "1/每秒神智消耗*伤害",
+    "每神智DPS": "or(攻速,1+技能速度)/神智消耗*伤害",
+    "每持续神智DPS": "or(攻速,1+技能速度)/每秒神智消耗*伤害",
+}
+
+
+def parse_ast(expr: str, macros: dict[str, str] | None = None) -> dict:
+    """解析表达式为 AST dict（缺省沿用 CharBuild.macros，与 TS 各调用点一致）。"""
+    return _Parser(expr, _normalize_macros(CHAR_MACROS if macros is None else macros)).parse()
+
+
+def tokenize_ast(expr: str, max_length: int | None = None) -> list[dict]:
+    """按 AST 词法扫描（宏名原样返回，不替换），供位置扫描使用。"""
+    limit = max_length if max_length is not None else float("inf")
+    tok = _Tokenizer(expr, {})
+    out = []
+    while True:
+        t = tok.next_token()
+        if t["kind"] == "EOF" or t["pos"] >= limit:
+            break
+        out.append(t)
+    return out