infinity-data 1.0.0__tar.gz

infinity_data-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 InfinitySystem (yin_bailiang)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

infinity_data-1.0.0/PKG-INFO

@@ -0,0 +1,60 @@
+Metadata-Version: 2.4
+Name: infinity-data
+Version: 1.0.0
+Summary: InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库
+Author: infinity_system: yin_bailiang
+License: MIT
+Project-URL: Repository, https://github.com/yinbailiang/infinity_data
+Project-URL: Documentation, https://github.com/yinbailiang/infinity_data#readme
+Keywords: config,configuration,declarative,dsl,compiler,infinity-data
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# InfinityData
+
+声明式配置语言（`.infd` / `.inft`）的 Python 编译器库。
+
+- **编译优先**：`.infd` 是源码，JSON/YAML/TOML 是构建产物
+- **模板即约束**：模板定义自动注册为约束校验器
+- **零信任默认**：库默认 `deny_all` 沙盒，显式开放而非事后限制
+- **结构化错误**：稳定错误码 + 结构化参数 + 多语言渲染
+
+## 快速使用
+
+```python
+from infinity_data import load, safe_load, SandboxConfig, Schema
+
+result = load('app.infd')              # 默认零信任
+if result.has_errors:
+    for d in result.diagnostics:
+        print(d.location, d.code, d.message)
+else:
+    print(result.value)                # 降维后的 dict
+```
+
+## 文档导航
+
+| 文档 | 内容 |
+|---|---|
+| [neo_desg.md](./neo_desg.md) | 语言基础设计（语法 / 类型 / 模板 / 约束） |
+| [extra_desg.md](./extra_desg.md) | 库 API / CLI / 生态设计 |
+| [impl_desg.md](./impl_desg.md) | 编译器实现层的取舍与假设 |
+
+## 开发
+
+```bash
+uv run pytest -q      # 测试
+uv run ruff check src tests   # lint
+uv run pyright        # 类型检查（strict）
+uv run python test.py # 错误报告演示
+```

infinity_data-1.0.0/README.md

@@ -0,0 +1,38 @@
+# InfinityData
+
+声明式配置语言（`.infd` / `.inft`）的 Python 编译器库。
+
+- **编译优先**：`.infd` 是源码，JSON/YAML/TOML 是构建产物
+- **模板即约束**：模板定义自动注册为约束校验器
+- **零信任默认**：库默认 `deny_all` 沙盒，显式开放而非事后限制
+- **结构化错误**：稳定错误码 + 结构化参数 + 多语言渲染
+
+## 快速使用
+
+```python
+from infinity_data import load, safe_load, SandboxConfig, Schema
+
+result = load('app.infd')              # 默认零信任
+if result.has_errors:
+    for d in result.diagnostics:
+        print(d.location, d.code, d.message)
+else:
+    print(result.value)                # 降维后的 dict
+```
+
+## 文档导航
+
+| 文档 | 内容 |
+|---|---|
+| [neo_desg.md](./neo_desg.md) | 语言基础设计（语法 / 类型 / 模板 / 约束） |
+| [extra_desg.md](./extra_desg.md) | 库 API / CLI / 生态设计 |
+| [impl_desg.md](./impl_desg.md) | 编译器实现层的取舍与假设 |
+
+## 开发
+
+```bash
+uv run pytest -q      # 测试
+uv run ruff check src tests   # lint
+uv run pyright        # 类型检查（strict）
+uv run python test.py # 错误报告演示
+```

infinity_data-1.0.0/pyproject.toml

@@ -0,0 +1,91 @@
+[project]
+name = "infinity-data"
+version = "1.0.0"
+description = "InfinityData：声明式配置语言（.infd/.inft）的 Python 编译器库"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [
+    { name = "infinity_system: yin_bailiang" },
+]
+keywords = [
+    "config",
+    "configuration",
+    "declarative",
+    "dsl",
+    "compiler",
+    "infinity-data",
+]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+]
+requires-python = ">=3.12"
+dependencies = []
+
+[project.urls]
+Repository = "https://github.com/yinbailiang/infinity_data"
+Documentation = "https://github.com/yinbailiang/infinity_data#readme"
+
+[dependency-groups]
+# 测试组：仅运行测试所需（CI test job 只装这组，更快）
+test = [
+    "pytest>=8.0",
+    "pytest-cov>=5.0",
+]
+# 开发组：lint/类型/钩子 + 测试组（本地开发与 CI pre-commit job 装这组）
+dev = [
+    "ruff>=0.15.21",
+    "pyright",
+    "pre-commit>=4.0",
+    "interrogate>=1.7.0",
+    { include-group = "test" },
+]
+
+[build-system]
+requires = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+package-dir = {"" = "src"}
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.ruff]
+line-length = 120
+target-version = "py312"
+
+[tool.ruff.lint]
+select = [
+    "E",      # pycodestyle errors
+    "F",      # pyflakes
+    "I",      # isort
+    "ASYNC",  # async/await best practices
+    "PLE",    # pylint errors
+]
+ignore = [
+    "E501",     # line too long (handled by formatter)
+    "ASYNC109", # async function with timeout parameter (intentional API design)
+]
+
+[tool.ruff.lint.isort]
+known-first-party = ["infinity_data"]
+
+[tool.ruff.format]
+indent-style = "space"
+quote-style = "single"
+line-ending = "lf"
+
+[tool.pyright]
+typeCheckingMode = "strict"
+reportMissingTypeStubs = false
+reportMissingImports = "error"
+exclude = ["**/node_modules", "**/__pycache__", "**/.*", ".venv"]
+venvPath = "."
+venv = ".venv"

infinity_data-1.0.0/setup.cfg

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

infinity_data-1.0.0/src/infinity_data/__init__.py

@@ -0,0 +1,41 @@
+"""InfinityData —— 声明式配置语言（.infd/.inft）的 Python 编译器库。
+
+编译流水线：RawTokenizer → FinalTokenizer → Parser → AstBuilder → Executor → Converter
+
+用法::
+
+    from infinity_data import load, safe_load, SandboxConfig, Schema
+
+    result = safe_load("app.infd")
+    if result.has_errors:
+        for d in result.diagnostics:
+            print(d.location, d.message)
+    else:
+        print(result.value)
+"""
+
+from infinity_data.infra.diagnostics import Diagnostic, Severity
+from infinity_data.pipeline import (
+    CompilationResult,
+    check,
+    compile_document,
+    compile_source,
+    load,
+    safe_load,
+)
+from infinity_data.sandbox import SandboxConfig, SandboxError, Schema, SchemaError
+
+__all__ = [
+    'compile_source',
+    'load',
+    'safe_load',
+    'check',
+    'compile_document',
+    'CompilationResult',
+    'SandboxConfig',
+    'SandboxError',
+    'Schema',
+    'SchemaError',
+    'Diagnostic',
+    'Severity',
+]

infinity_data-1.0.0/src/infinity_data/emit/__init__.py

@@ -0,0 +1,9 @@
+"""产物发射层：StdAst → 宿主表示（Python dict / list / 标量）。
+
+语义分析（semantic/）负责"值是否正确"，本层负责"产物长什么样"。
+M4 的 JSON/YAML/TOML 转换、M5 的 JSON Schema 生成均在此层扩展。
+"""
+
+from infinity_data.emit.converter import reduce_array, reduce_object, reduce_value
+
+__all__ = ['reduce_array', 'reduce_object', 'reduce_value']

infinity_data-1.0.0/src/infinity_data/emit/converter.py

@@ -0,0 +1,55 @@
+"""降维器：StdAst → 纯 Python 值（dict / list / 标量）。
+
+- ``noexist`` 字段不出现在输出中
+- ``null`` 字段保留键（值为 None），``keep_null=False`` 时跳过
+- 浮点保持 :class:`decimal.Decimal`（无限精度）；NaN / ±Infinity 以 Decimal 表示，
+  JSON/YAML 序列化时的特殊编码由 M4 转换层负责
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+from infinity_data.semantic.builder.models import StdArray, StdLiteral, StdObject, StdValue
+
+
+def reduce_object(obj: StdObject, *, keep_null: bool = True) -> dict[str, Any]:
+    """将 StdObject 降维为 Python dict。"""
+    result: dict[str, Any] = {}
+    for f in obj.fields:
+        if f.value is None or f.is_noexist:
+            continue
+        if f.is_null:
+            if keep_null:
+                result[f.name] = None
+            continue
+        result[f.name] = reduce_value(f.value, keep_null=keep_null)
+    return result
+
+
+def reduce_array(arr: StdArray, *, keep_null: bool = True) -> list[Any]:
+    """将 StdArray 降维为 Python list。"""
+    return [reduce_value(v, keep_null=keep_null) for v in arr.elements]
+
+
+def reduce_value(val: StdValue, *, keep_null: bool = True) -> Any:
+    """将任意 StdValue 降维为 Python 原生值。"""
+    match val:
+        case StdLiteral():
+            return _reduce_literal(val)
+        case StdArray():
+            return reduce_array(val, keep_null=keep_null)
+        case StdObject():
+            return reduce_object(val, keep_null=keep_null)
+    raise TypeError(f'未知 StdValue 类型: {type(val)}')
+
+
+# ── 内部 ────────────────────────────────────────────────
+
+
+def _reduce_literal(lit: StdLiteral) -> Any:
+    match lit.kind:
+        case 'null' | 'noexist':
+            return None
+        case _:
+            return lit.value

infinity_data-1.0.0/src/infinity_data/frontend.py

@@ -0,0 +1,37 @@
+"""前端流水线：源码 File → RawAst Document + 前端诊断（容错收集）。
+
+供 :mod:`pipeline`（主文件）与 :mod:`semantic.resolver`（外部模板文件）共用，
+消除两处重复的 RawTokenizer → FinalTokenizer → Parser 组装。
+"""
+
+from infinity_data.infra.diagnostics import DiagnosticCollector
+from infinity_data.infra.file import File
+from infinity_data.parser import Document
+from infinity_data.parser.parser import Parser
+from infinity_data.tokenizer.finalizer import FinalTokenizer
+from infinity_data.tokenizer.tokenizer import RawTokenizer
+
+__all__ = ['parse_source']
+
+
+def parse_source(
+    file: File,
+    collector: DiagnosticCollector | None = None,
+) -> tuple[Document, DiagnosticCollector]:
+    """词法 + 语法分析，返回 RawAst Document 与生效收集器。
+
+    容错：词法/语法错误经 :class:`DiagnosticCollector` 收集而非抛出。
+    传入 ``collector`` 时三阶段（RawTokenizer / FinalTokenizer / Parser）全程
+    复用同一收集器并**原样返回**（非副本）；缺省时内部新建并返回。
+    返回值第二元素为生效收集器，可直接查询 errors / warnings / has_errors。
+    """
+    if collector is None:
+        collector = DiagnosticCollector()
+
+    raw_tokens = RawTokenizer(file=file, error_collector=collector)
+    tokens = FinalTokenizer(raw_tokens, error_collector=collector)
+    parser = Parser(tokens, error_collector=collector)
+    doc = parser.parse()
+
+    # 词法/语法错误统一为 Diagnostic（纯数据，直接聚合）
+    return doc, collector

infinity_data-1.0.0/src/infinity_data/infra/__init__.py

@@ -0,0 +1,4 @@
+from infinity_data.infra.diagnostics import Diagnostic, DiagnosticCollector, Severity
+from infinity_data.infra.ll1_stream import LL1Stream
+
+__all__ = ['Diagnostic', 'DiagnosticCollector', 'Severity', 'LL1Stream']

infinity_data-1.0.0/src/infinity_data/infra/diagnostics.py

@@ -0,0 +1,212 @@
+"""统一诊断模型（所有阶段共用）与容错收集器。
+
+- :class:`Severity` / :class:`Diagnostic`：稳定错误码 + 结构化参数 + 渲染消息。
+  词法/语法/语义阶段统一使用；沙盒异常（见 :mod:`infinity_data.sandbox.errors`）
+  经 ``check()`` 边界转换为 Diagnostic。
+- :class:`DiagnosticCollector`：前端容错收集器（词法/语法错误作为 Diagnostic
+  收集，从不抛异常）。
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterable, Iterator, Mapping
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+from infinity_data.infra.location import SourceRange, format_location
+
+__all__ = [
+    'DEFAULT_LANG',
+    'Severity',
+    'Diagnostic',
+    'DiagnosticDefine',
+    'diagnostic_define',
+    'register_diagnostic_define',
+    'render_message',
+    'DiagnosticCollector',
+]
+
+DEFAULT_LANG = 'zh'
+"""默认渲染语言。"""
+
+
+class Severity(Enum):
+    """诊断严重级别。"""
+
+    ERROR = 'error'
+    WARNING = 'warning'
+    INFO = 'info'
+
+
+@dataclass(frozen=True)
+class Diagnostic:
+    """统一诊断：稳定错误码 + 结构化参数 + 渲染消息。
+
+    - ``code``：稳定错误码（如 ``"template.undefined"``），测试/工具据此匹配
+    - ``params``：结构化参数；``message`` 为派生属性，由注册表按语言渲染
+    - ``lang``：渲染语言（None = 默认语言）；模板缺失时回退默认语言
+    """
+
+    severity: Severity
+    code: str
+    params: Mapping[str, Any] = field(default_factory=dict[str, Any])
+    source: SourceRange | None = None
+    path: str = ''
+    lang: str | None = None
+
+    @property
+    def location(self) -> str:
+        return format_location(self.source)
+
+    @property
+    def message(self) -> str:
+        """按错误码 + 参数 + 语言渲染的人类可读消息。"""
+        return render_message(
+            self.code, self.params, location=self.location, path=self.path, lang=self.lang or DEFAULT_LANG
+        )
+
+    def sort_key(self) -> tuple[str, int, int]:
+        """按源码位置排序。"""
+        if self.source is None:
+            return ('\uffff', 0, 0)
+        s = self.source.start
+        return (self.source.file.name, s.line, s.col)
+
+
+@dataclass(frozen=True)
+class DiagnosticDefine:
+    """诊断定义：稳定错误码 + 语言模板。
+
+    - ``code``：稳定错误码（如 ``"template.undefined"``）
+    - ``template``：默认语言（``DEFAULT_LANG``）模板
+    - ``translations``：其他语言模板（语言码 → 模板），缺失时回退默认模板
+    """
+
+    code: str
+    template: str
+    translations: Mapping[str, str] = field(default_factory=dict[str, str])
+
+    def template_for(self, lang: str = DEFAULT_LANG) -> str:
+        """取指定语言的模板；缺失回退默认模板。"""
+        if lang == DEFAULT_LANG:
+            return self.template
+        return self.translations.get(lang, self.template)
+
+
+_DIAGNOSTIC_DEFINE_REGISTRY: dict[str, DiagnosticDefine] = {}
+"""诊断定义注册表（code → 定义）。"""
+
+
+def diagnostic_define(code: str, template: str, **translations: str) -> DiagnosticDefine:
+    """构造诊断定义（``translations`` 为其他语言模板，如 ``en=...``）。"""
+    return DiagnosticDefine(code=code, template=template, translations=translations)
+
+
+def register_diagnostic_define(*defines: DiagnosticDefine) -> None:
+    """注册诊断定义（重复 code 后者覆盖）。"""
+    for d in defines:
+        _DIAGNOSTIC_DEFINE_REGISTRY[d.code] = d
+
+
+def registered_diagnostic_defines() -> Mapping[str, DiagnosticDefine]:
+    """已注册定义表（只读视图）。"""
+    return _DIAGNOSTIC_DEFINE_REGISTRY
+
+
+def render_message(
+    code: str,
+    params: Mapping[str, Any],
+    *,
+    location: str = '<unknown>',
+    path: str = '',
+    lang: str = DEFAULT_LANG,
+) -> str:
+    """按错误码 + 参数 + 语言渲染消息；未知错误码原样返回错误码本身。"""
+    d = _DIAGNOSTIC_DEFINE_REGISTRY.get(code)
+    if d is None:
+        return code
+    template = d.template_for(lang)
+    context: dict[str, Any] = {
+        'location': location,
+        'path': path,
+        'path_prefix': f'{path}: ' if path else '',
+        **params,
+    }
+    try:
+        return template.format(**context)
+    except (KeyError, IndexError, ValueError, AttributeError):
+        return code
+
+
+class DiagnosticCollector:
+    """诊断收集器：收集 :class:`Diagnostic`（词法/语法/语义阶段容错收集）。
+
+    词法/语法/语义阶段不抛异常：错误以 Diagnostic 形式收集，边界处直接聚合。
+    只读查询按 severity 分离：``errors`` / ``warnings`` / ``diagnostics``，
+    ``has_errors`` 仅当含 ERROR 级别时成立（warning 不算错误）。
+
+    用法::
+
+        collector = DiagnosticCollector()
+        tokenizer = RawTokenizer(file, error_collector=collector)
+        ...
+        for err in collector:
+            print(err.code)
+    """
+
+    def __init__(self) -> None:
+        self._errors: list[Diagnostic] = []
+
+    # ── 写入 ──────────────────────────────────────────
+
+    def add(self, error: Diagnostic) -> None:
+        """添加一个诊断。"""
+        self._errors.append(error)
+
+    def extend(self, errors: Iterable[Diagnostic]) -> None:
+        """批量添加诊断。"""
+        self._errors.extend(errors)
+
+    # ── 只读查询（severity 感知：warning 与 error 语义分离） ──
+
+    @property
+    def diagnostics(self) -> list[Diagnostic]:
+        """全部诊断的副本（含 ERROR / WARNING）。"""
+        return self._errors.copy()
+
+    @property
+    def errors(self) -> list[Diagnostic]:
+        """仅 ERROR 级别诊断的副本（warning 不算错误）。"""
+        return [d for d in self._errors if d.severity is Severity.ERROR]
+
+    @property
+    def warnings(self) -> list[Diagnostic]:
+        """仅 WARNING 级别诊断的副本。"""
+        return [d for d in self._errors if d.severity is Severity.WARNING]
+
+    @property
+    def has_errors(self) -> bool:
+        """是否含 ERROR 级别诊断（与 :class:`CompilationResult` 的 has_errors 语义一致）。"""
+        return any(d.severity is Severity.ERROR for d in self._errors)
+
+    @property
+    def has_warnings(self) -> bool:
+        """是否含 WARNING 级别诊断。"""
+        return any(d.severity is Severity.WARNING for d in self._errors)
+
+    # ── 容器协议 ──────────────────────────────────────
+
+    def __iter__(self) -> Iterator[Diagnostic]:
+        """迭代所有已收集的诊断。"""
+        return iter(self._errors)
+
+    def __len__(self) -> int:
+        """已收集诊断数量（容器协议）。
+
+        空收集器为 falsy（``bool(collector)`` = 是否收集到任何诊断，含 warning；
+        区别于 ``has_errors`` 的"是否含 ERROR"）——
+        因此缺省构造**不可用 ``error_collector or DiagnosticCollector()``**：
+        空收集器会被 `or` 判定为假而静默替换，丢弃调用方传入的收集器。
+        """
+        return len(self._errors)

infinity_data-1.0.0/src/infinity_data/infra/file.py

@@ -0,0 +1,83 @@
+"""源码来源抽象：磁盘文件与内存源码统一为 :class:`File`。
+
+编译入口（``load`` / ``compile_source``）与模板导入链（``!from``）都消费 File：
+
+- ``name``：诊断显示名（``file:line:col`` 中的 file）
+- ``root_path``：相对导入解析基准（所在目录）
+- ``read()``：源码内容
+- ``chars()``：逐字符迭代流（词法分析输入）
+- ``identity``：唯一身份（磁盘 = resolve 后绝对路径；内存 = ``路径:mem:内容hash``）；模板身份（TemplateKey）基于它，含来源路径
+- ``content_hash()``：内容 sha256 前缀（MemFile 身份的一部分 / 内容校验）
+"""
+
+import hashlib
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+
+__all__ = ['File', 'DiskFile', 'MemFile']
+
+
+@dataclass(frozen=True)
+class File:
+    """源码来源基类。"""
+
+    name: str
+    root_path: Path
+
+    def read(self) -> str:
+        """读取源码内容。"""
+        raise NotImplementedError
+
+    def chars(self) -> Iterable[str]:
+        """逐字符迭代流（词法分析输入）。"""
+        return iter(self.read())
+
+    @property
+    def identity(self) -> str:
+        """唯一身份（循环导入防护 / 模板身份（TemplateKey）基础，含来源路径）。"""
+        raise NotImplementedError
+
+    def content_hash(self) -> str:
+        """内容 sha256 前缀（MemFile 身份的一部分；内容校验，非模板身份本身）。"""
+        return hashlib.sha256(self.read().encode('utf-8')).hexdigest()[:12]
+
+
+@dataclass(frozen=True)
+class DiskFile(File):
+    """磁盘文件。path 为单一事实来源；name/root_path 由构造方从它派生。"""
+
+    @property
+    def path(self) -> Path:
+        return Path(self.name)
+
+    def read(self) -> str:
+        return self.path.read_text(encoding='utf-8')
+
+    @property
+    def identity(self) -> str:
+        return str(self.path.resolve())
+
+    @classmethod
+    def from_fullpath(cls, fullpath: str | Path) -> 'DiskFile':
+        """从完整路径构造（与调用点一致的规范化入口）。"""
+        p = Path(fullpath)
+        return cls(name=str(p), root_path=p.parent)
+
+
+@dataclass(frozen=True)
+class MemFile(File):
+    """内存源码（测试/嵌入式场景）。身份 = 根路径:mem:内容hash（含路径）。"""
+
+    content: str
+
+    def read(self) -> str:
+        return self.content
+
+    def chars(self) -> Iterable[str]:
+        """逐字符迭代流（O(1) 构造，直连内容）。"""
+        return iter(self.content)
+
+    @property
+    def identity(self) -> str:
+        return str(self.root_path.resolve()) + ':mem:' + self.content_hash()