infinity-data 2.1.0__tar.gz → 2.2.1__tar.gz

{infinity_data-2.1.0/src/infinity_data.egg-info → infinity_data-2.2.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: infinity-data
-Version: 2.1.0
+Version: 2.2.1
 Summary: InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库
 Author: infinity_system: yin_bailiang
 License: MIT

{infinity_data-2.1.0 → infinity_data-2.2.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "infinity-data"
-version = "2.1.0"
+version = "2.2.1"
 description = "InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库"
 readme = "README.md"
 license = { text = "MIT" }
@@ -35,6 +35,7 @@ Documentation = "https://github.com/yinbailiang/infinity_data#readme"
 [dependency-groups]
 # 测试组：仅运行测试所需（CI test job 只装这组，更快）
 test = [
+    "pyyaml",
     "pytest>=8.0",
     "pytest-cov>=5.0",
 ]
@@ -89,7 +90,7 @@ line-ending = "lf"
 typeCheckingMode = "strict"
 reportMissingTypeStubs = false
 reportMissingImports = "error"
-exclude = ["**/node_modules", "**/__pycache__", "**/.*", ".venv"]
+exclude = ["**/node_modules", "**/__pycache__", "**/.*", ".venv", "build"]
 venvPath = "."
 venv = ".venv"
 

{infinity_data-2.1.0 → infinity_data-2.2.1}/src/infinity_data/parser/__init__.py

@@ -34,6 +34,7 @@ from infinity_data.parser.models import (
     JsonPathKey,
     JsonPathSegment,
     LiteralValue,
+    NamedArg,
     Statement,
     TemplateCallValue,
     TemplateConfig,
@@ -72,6 +73,7 @@ __all__ = [
     'JsonPathKey',
     'JsonPathSegment',
     'LiteralValue',
+    'NamedArg',
     'Parser',
     'Statement',
     'TemplateCallValue',

{infinity_data-2.1.0 → infinity_data-2.2.1}/src/infinity_data/parser/models.py

@@ -37,6 +37,16 @@ def _canonical_constraint_list(constraints: Iterable['Constraint']) -> str:
     return '<' + ', '.join(c.canonical() for c in items) + '>'
 
 
+def _canonical_error(message: str) -> str:
+    """错误节点容错序列化：``error("...")`` 占位符。
+
+    错误节点是**解析失败恢复**的产物，对应的源码本就无效，无法还原为等价 AST——
+    canonical 仅作**容错**（模板真名哈希 / 调试 / LSP 提示不因错误节点崩溃），
+    不承诺 round-trip（``error(...)`` 是显示占位符，不是可解析的模板调用语法）。
+    """
+    return f'error({_canonical_str(message)})'
+
+
 # ═══════════════════════════════════════════════════════════
 # 节点
 # ═══════════════════════════════════════════════════════════
@@ -457,24 +467,41 @@ class UnpackValue(AstNode):
         return ('**' if self.double else '*') + self.value.canonical()
 
 
+@dataclass
+class NamedArg(AstNode):
+    """模板调用命名参数槽: name = value。
+
+    与 ``**expr`` 解包项（:class:`UnpackValue`）在 :attr:`TemplateCallValue.named_args`
+    中按**源码顺序**混排——键冲突「保留先到者」（disjoint merge，§2.7）与书写顺序一致。
+    """
+
+    name: str
+    value: Value
+
+    def children(self) -> Iterable[AstNode]:
+        return [self.value]
+
+    def canonical(self) -> str:
+        return f'{self.name} = {self.value.canonical()}'
+
+
 @dataclass
 class DictValue(AstNode):
     """对象值: { ... }
 
     ``: <constraint, ...>`` 结构级约束作用于该字面量 dict 的整体。
-    ``unpacks``：``**expr`` 解包项（展开为键值对后并入字段集）。
+    ``items``：字段（:class:`Field`）与 ``**expr`` 解包项（:class:`UnpackValue`）按
+    **源码顺序**混排——键冲突「保留先到者」（disjoint merge，§2.7）与书写顺序一致。
     """
 
-    fields: list[Field]
+    items: list[Field | UnpackValue]
     constraints: list[Constraint] = field(default_factory=lambda: [])
-    unpacks: list[UnpackValue] = field(default_factory=lambda: [])
 
     def children(self) -> Iterable[AstNode]:
-        return [*self.fields, *self.constraints, *self.unpacks]
+        return [*self.items, *self.constraints]
 
     def canonical(self) -> str:
-        inner: list[str] = [f.canonical() for f in self.fields]
-        inner.extend(u.canonical() for u in self.unpacks)
+        inner: list[str] = [i.canonical() for i in self.items]
         cs = _canonical_constraint_list(self.constraints)
         if cs:
             inner.append(': ' + cs)
@@ -501,18 +528,21 @@ class TemplateCallValue(AstNode):
     展开（§2.8）：参数值后缀 ``...`` = 展开轴；调用级（``)`` 后）``...`` = 展开传播
     （本调用的展开结果作为包围模板调用的轴，整体模式逐元素重复）、``^`` = 笛卡尔积
     （多轴全组合，首轴最慢变化；与 ``propagate`` 正交，``^...`` 可叠加）。
-    - ``axis_positional``：位置参数中带 ``...`` 的索引
-    - ``axis_named``：命名参数中带 ``...`` 的键
-    - ``axis_unpack_kwargs``：``**expr`` 解包参数中带 ``...`` 的索引
+    - ``positional_args``：位置参数槽，**保持源码顺序**；``*expr`` 解包项
+      （:class:`UnpackValue`，double=False）也在其中，实例化时展开为多个位置参数（§2.7）
+    - ``named_args``：命名参数槽，**保持源码顺序**；显式 ``name = value``（:class:`NamedArg`）
+      与 ``**expr`` 解包项（:class:`UnpackValue`，double=True）混排——键冲突「保留先到者」
+      与书写顺序一致（§2.7 disjoint merge）
+    - ``axis_positional``：位置参数槽中带 ``...`` 的索引（``*expr`` 解包项不是轴）
+    - ``axis_named``：命名参数（:class:`NamedArg`）中带 ``...`` 的键
+    - ``axis_unpack_kwargs``：``**expr`` 解包项（named_args 槽索引）中带 ``...`` 的索引
     - ``propagate``：调用级 ``...``（展开传播；无 = 展开止于本调用）
     - ``cartesian``：调用级 ``^``（笛卡尔积展开；无 = zip 配对）
     """
 
     template_name: str
-    positional_args: list[Value]
-    named_args: dict[str, Value]
-    unpack_args: list[UnpackValue] = field(default_factory=lambda: [])  # *expr（list → 位置参数）
-    unpack_kwargs: list[UnpackValue] = field(default_factory=lambda: [])  # **expr（dict → 命名参数）
+    positional_args: list[Value | UnpackValue]
+    named_args: list[NamedArg | UnpackValue]
     axis_positional: frozenset[int] = field(default_factory=frozenset[int])
     axis_named: frozenset[str] = field(default_factory=frozenset[str])
     axis_unpack_kwargs: frozenset[int] = field(default_factory=frozenset[int])
@@ -522,27 +552,22 @@ class TemplateCallValue(AstNode):
     def children(self) -> Iterable[AstNode]:
         return [
             *self.positional_args,
-            *self.named_args.values(),
-            *self.unpack_args,
-            *self.unpack_kwargs,
+            *self.named_args,
         ]
 
     def canonical(self) -> str:
         args: list[str] = []
         for i, a in enumerate(self.positional_args):
             s = a.canonical()
-            if i in self.axis_positional:
-                s += '...'
-            args.append(s)
-        args.extend(u.canonical() for u in self.unpack_args)
-        for k, v in sorted(self.named_args.items()):
-            s = f'{k} = {v.canonical()}'
-            if k in self.axis_named:
+            if not isinstance(a, UnpackValue) and i in self.axis_positional:
                 s += '...'
             args.append(s)
-        for j, u in enumerate(self.unpack_kwargs):
-            s = u.canonical()
-            if j in self.axis_unpack_kwargs:
+        for i, n in enumerate(self.named_args):
+            s = n.canonical()
+            if isinstance(n, UnpackValue):
+                if i in self.axis_unpack_kwargs:
+                    s += '...'
+            elif n.name in self.axis_named:
                 s += '...'
             args.append(s)
         out = f'{self.template_name}({", ".join(args)})'
@@ -560,32 +585,41 @@ class TemplateCallValue(AstNode):
 
 @dataclass
 class ErrorStatement(AstNode):
-    """解析失败的语句。用于错误恢复。"""
+    """解析失败的语句。用于错误恢复。
+
+    canonical 容错输出 ``error("message")``（不抛异常），供哈希 / LSP 提示。
+    """
 
     message: str
 
     def canonical(self) -> str:
-        raise TypeError('错误节点不可序列化为 infd')
+        return _canonical_error(self.message)
 
 
 @dataclass
 class ErrorValue(AstNode):
-    """解析失败的值。用于错误恢复。"""
+    """解析失败的值。用于错误恢复。
+
+    canonical 容错输出 ``error("message")``（不抛异常），供哈希 / LSP 提示。
+    """
 
     message: str
 
     def canonical(self) -> str:
-        raise TypeError('错误节点不可序列化为 infd')
+        return _canonical_error(self.message)
 
 
 @dataclass
 class ErrorConstraint(AstNode):
-    """解析失败的约束。用于错误恢复。"""
+    """解析失败的约束。用于错误恢复。
+
+    canonical 容错输出 ``error("message")``（不抛异常），供哈希 / LSP 提示。
+    """
 
     message: str
 
     def canonical(self) -> str:
-        raise TypeError('错误节点不可序列化为 infd')
+        return _canonical_error(self.message)
 
 
 # ═══════════════════════════════════════════════════════════

{infinity_data-2.1.0 → infinity_data-2.2.1}/src/infinity_data/parser/parser.py

@@ -29,6 +29,7 @@ from infinity_data.parser.models import (
     JsonPathKey,
     JsonPathSegment,
     LiteralValue,
+    NamedArg,
     Statement,
     TemplateCallValue,
     TemplateConfig,
@@ -1196,8 +1197,7 @@ class Parser:
         lbrace_tok = stream.expect(LbraceToken)
         stream.skip_separators()
 
-        fields: list[Field] = []
-        unpacks: list[UnpackValue] = []
+        items: list[Field | UnpackValue] = []
         constraints: list[Constraint] = []
         missing_sep_reported = [False]
         while not stream.check(RawTokenType.RBRACE) and not stream.eof():
@@ -1207,12 +1207,13 @@ class Parser:
                 parsed = Parser._parse_constraints(stream, collector)
                 constraints.extend(parsed.constraints)
             elif isinstance(stream.peek(), DoubleStarToken):
-                # **expr：dict 解包（展开为键值对并入字段集）
+                # **expr：dict 解包（展开为键值对并入字段集）；
+                # 与显式字段同槽存放，保持源码顺序（先到者胜出，§2.7）
                 tok = stream.expect(DoubleStarToken)
                 val = Parser._parse_value(stream, collector)
-                unpacks.append(UnpackValue(source=stream.span_from(tok), value=val, double=True))
+                items.append(UnpackValue(source=stream.span_from(tok), value=val, double=True))
             else:
-                fields.append(Parser._parse_field(stream, collector))
+                items.append(Parser._parse_field(stream, collector))
             had_sep = stream.skip_separators()
             Parser._missing_separator(
                 stream,
@@ -1224,7 +1225,7 @@ class Parser:
             )
 
         stream.expect(RbraceToken)
-        return DictValue(source=stream.span_from(lbrace_tok), fields=fields, constraints=constraints, unpacks=unpacks)
+        return DictValue(source=stream.span_from(lbrace_tok), items=items, constraints=constraints)
 
     @staticmethod
     def _parse_array(stream: TokenStream, collector: DiagnosticCollector) -> ArrayValue:
@@ -1263,13 +1264,11 @@ class Parser:
         stream.expect(LparenToken)
         stream.skip_newlines()
 
-        positional: list[Value] = []
-        named: dict[str, Value] = {}
-        unpack_args: list[UnpackValue] = []  # *expr（list → 位置参数）
-        unpack_kwargs: list[UnpackValue] = []  # **expr（dict → 命名参数）
-        axis_positional: set[int] = set()  # 位置参数中带 ... 的索引（展开轴，§2.8）
+        positional: list[Value | UnpackValue] = []  # 位置参数 + *expr 解包项（保持源码顺序，§2.7）
+        named: list[NamedArg | UnpackValue] = []  # 命名参数 + **expr 解包项（保持源码顺序，§2.7）
+        axis_positional: set[int] = set()  # 位置参数槽中带 ... 的索引（展开轴，§2.8）
         axis_named: set[str] = set()  # 命名参数中带 ... 的键
-        axis_unpack_kwargs: set[int] = set()  # **expr 解包参数中带 ... 的索引
+        axis_unpack_kwargs: set[int] = set()  # named 槽中 **expr 解包项的索引
         saw_named = False
         missing_sep_reported = [False]
 
@@ -1284,15 +1283,16 @@ class Parser:
             if isinstance(tok, DoubleStarToken):
                 stream.advance()
                 val = Parser._parse_value(stream, collector)
-                idx = len(unpack_kwargs)
-                unpack_kwargs.append(UnpackValue(source=stream.single_span(tok), value=val, double=True))
+                idx = len(named)
+                named.append(UnpackValue(source=stream.single_span(tok), value=val, double=True))
                 if Parser._consume_ellipsis(stream):
                     axis_unpack_kwargs.add(idx)  # **expr...：list[dict] 逐元素解包（§2.8）
                 saw_named = True
             elif isinstance(tok, StarToken):
                 stream.advance()
                 val = Parser._parse_value(stream, collector)
-                unpack_args.append(UnpackValue(source=stream.single_span(tok), value=val, double=False))
+                # *expr 解包项与显式位置参数同槽存放，保持源码顺序（§2.7）
+                positional.append(UnpackValue(source=stream.single_span(tok), value=val, double=False))
             # 分支 1：标识符 → 可能是命名参数或模板调用（位置参数）
             elif isinstance(tok, IdentifierToken):
                 ident: IdentifierToken = stream.expect(IdentifierToken)  # 消费到缓冲区
@@ -1300,7 +1300,7 @@ class Parser:
 
                 if isinstance(nxt, EqualsToken):
                     stream.advance()  # 消费 =
-                    if ident.name in named:
+                    if ident.name in {s.name for s in named if isinstance(s, NamedArg)}:
                         collector.add(
                             diag(
                                 'template.dup_argument',
@@ -1308,7 +1308,13 @@ class Parser:
                                 stream.single_span(ident),
                             )
                         )
-                    named[ident.name] = Parser._parse_value(stream, collector)
+                    named.append(
+                        NamedArg(
+                            source=stream.single_span(ident),
+                            name=ident.name,
+                            value=Parser._parse_value(stream, collector),
+                        )
+                    )
                     if Parser._consume_ellipsis(stream):
                         axis_named.add(ident.name)  # 命名参数轴
                     saw_named = True
@@ -1358,8 +1364,6 @@ class Parser:
             template_name=name_tok.name,
             positional_args=positional,
             named_args=named,
-            unpack_args=unpack_args,
-            unpack_kwargs=unpack_kwargs,
             axis_positional=frozenset(axis_positional),
             axis_named=frozenset(axis_named),
             axis_unpack_kwargs=frozenset(axis_unpack_kwargs),

{infinity_data-2.1.0 → infinity_data-2.2.1}/src/infinity_data/pipeline.py

@@ -137,7 +137,7 @@ def _compile(file: File, options: CompileOptions) -> CompilationResult:
                 if resolver.schema.from_file and context.schema_scope is not None
                 else context.root_scope
             )
-            key = scope.get(resolver.schema.template)
+            key = scope.visible.get(resolver.schema.template)
             if key is None:
                 raise SchemaError('schema.undefined_template', {'template': resolver.schema.template})
             tpl = std.templates[key]

{infinity_data-2.1.0 → infinity_data-2.2.1}/src/infinity_data/semantic/builder/__init__.py

@@ -13,8 +13,10 @@ from infinity_data.semantic.builder.models import (
     StdDocument,
     StdField,
     StdLiteral,
+    StdNode,
     StdObject,
     StdValue,
+    is_std_node,
 )
 
 __all__ = [
@@ -24,6 +26,8 @@ __all__ = [
     'StdDocument',
     'StdField',
     'StdLiteral',
+    'StdNode',
     'StdObject',
     'StdValue',
+    'is_std_node',
 ]