precis-cli 0.1.3__py3-none-any.whl

app/shared/core/manifest_schema/version.py

@@ -0,0 +1,175 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview Schema 版本管理模块
+
+功能概述:
+- 定义配置格式版本常量及支持范围检查
+- 提供版本号解析、比较和版本信息查询功能
+
+架构设计:
+- 使用模块级常量定义当前版本和支持范围
+- 提供纯工具函数，无外部依赖，便于各模块调用
+
+输入示例:
+    is_supported_version(2)        -> True
+    parse_version("2.1.0")         -> (2, 1, 0)
+    compare_versions((2, 0, 0), (2, 1, 0))  -> -1
+
+输出示例:
+    get_version_info() -> {
+        "current_version": 2,
+        "min_supported_version": 2,
+        "max_supported_version": 2,
+        "supported_versions": [2],
+    }
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+# ============================================================================
+# 版本常量定义
+# ============================================================================
+
+# 当前配置格式版本号
+CURRENT_VERSION = 2
+
+# 系统最小支持的配置版本号
+MIN_SUPPORTED_VERSION = 2
+
+# 系统最大支持的配置版本号
+MAX_SUPPORTED_VERSION = 2
+
+
+# ============================================================================
+# 版本检查与查询函数
+# ============================================================================
+
+
+def is_supported_version(version: int) -> bool:
+    """
+    @methoddesc 检查指定版本号是否在系统支持范围内。
+
+    参数:
+        version: 要检查的版本号（整数）
+
+    返回值:
+        bool: 如果版本号在最小和最大支持版本之间（含边界）则返回 True，否则返回 False
+
+    使用示例:
+        >>> is_supported_version(2)
+        True
+        >>> is_supported_version(1)
+        False
+    """
+    return MIN_SUPPORTED_VERSION <= version <= MAX_SUPPORTED_VERSION
+
+
+def get_version_info() -> dict[str, Any]:
+    """
+    @methoddesc 获取当前系统的版本信息汇总。
+
+    返回值:
+        dict: 包含当前版本、最小支持版本、最大支持版本和支持版本列表的字典
+
+    字段说明:
+        - current_version: 当前配置格式版本
+        - min_supported_version: 最小支持的版本号
+        - max_supported_version: 最大支持的版本号
+        - supported_versions: 支持的所有版本号列表（由最小到最大生成的连续整数列表）
+
+    使用示例:
+        >>> get_version_info()
+        {'current_version': 2, 'min_supported_version': 2, 'max_supported_version': 2, 'supported_versions': [2]}
+    """
+    return {
+        "current_version": CURRENT_VERSION,
+        "min_supported_version": MIN_SUPPORTED_VERSION,
+        "max_supported_version": MAX_SUPPORTED_VERSION,
+        # 生成从最小支持版本到最大支持版本的连续版本号列表
+        "supported_versions": list(range(MIN_SUPPORTED_VERSION, MAX_SUPPORTED_VERSION + 1)),
+    }
+
+
+# ============================================================================
+# 版本号解析与比较函数
+# ============================================================================
+
+
+def parse_version(version_str: str) -> tuple[int, int, int]:
+    """
+    @methoddesc 将版本号字符串解析为 (主版本, 次版本, 修订号) 三元组。
+
+    参数:
+        version_str: 版本号字符串，格式通常为 "主版本.次版本.修订号"，如 "2.1.0"
+
+    返回值:
+        tuple[int, int, int]: (major, minor, patch) 三元组；
+                             如果某部分缺失，则对应位置默认为 0
+
+    解析逻辑:
+        1. 按小数点分割字符串
+        2. 依次取第 1、2、3 部分转为整数
+        3. 不足三部分时，缺失部分补 0
+
+    使用示例:
+        >>> parse_version("2.1.0")
+        (2, 1, 0)
+        >>> parse_version("3")
+        (3, 0, 0)
+    """
+    parts = version_str.split(".")
+    # 取主版本号，如果不存在则默认为 0
+    major = int(parts[0]) if len(parts) > 0 else 0
+    # 取次版本号，如果不存在则默认为 0
+    minor = int(parts[1]) if len(parts) > 1 else 0
+    # 取修订号，如果不存在则默认为 0
+    patch = int(parts[2]) if len(parts) > 2 else 0
+    return (major, minor, patch)
+
+
+def compare_versions(v1: tuple[int, int, int], v2: tuple[int, int, int]) -> int:
+    """
+    @methoddesc 比较两个版本号三元组的大小。
+
+    参数:
+        v1: 第一个版本号三元组 (major, minor, patch)
+        v2: 第二个版本号三元组 (major, minor, patch)
+
+    返回值:
+        int: -1 表示 v1 < v2，0 表示 v1 == v2，1 表示 v1 > v2
+
+    比较逻辑:
+        直接利用 Python 元组的字典序比较特性：
+        先比较主版本，若相同再比较次版本，若仍相同再比较修订号
+
+    使用示例:
+        >>> compare_versions((2, 0, 0), (2, 1, 0))
+        -1
+        >>> compare_versions((3, 0, 0), (2, 9, 9))
+        1
+        >>> compare_versions((1, 1, 1), (1, 1, 1))
+        0
+    """
+    # 利用 Python 元组的字典序比较特性进行版本号大小判断
+    if v1 < v2:
+        return -1
+    elif v1 > v2:
+        return 1
+    else:
+        return 0

app/shared/core/patterns/__init__.py

@@ -0,0 +1,24 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""@fileoverview 表达式模式模块入口
+
+功能概述:
+- 导出表达式模式加载函数（load_patterns_from_config）
+"""
+
+from .loader import load_patterns_from_config
+
+__all__ = ["load_patterns_from_config"]

app/shared/core/patterns/loader.py

@@ -0,0 +1,134 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""@fileoverview 表达式模式加载模块
+
+功能概述:
+- 从 patterns/ 目录加载 YAML 规则文件并编译为正则表达式
+- 将 ExpressionPattern 注册到 ExpressionRegistry 供系统使用
+
+架构设计:
+- 为避免 core 层反向依赖 domain.expression_system，
+  domain 相关类在函数内部延迟导入。
+- 返回类型使用字符串前向引用，满足类型注解需求。
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import re
+
+logger = logging.getLogger(__name__)
+from pathlib import Path
+from typing import Any
+
+from ..io.yaml import read_yaml
+
+
+def load_patterns_from_config(base_dir: str) -> Any:
+    """
+    从指定的配置目录加载所有 YAML 规则文件。
+
+    本函数遍历指定目录下的所有 .yaml 和 .yml 文件，
+    将每个文件解析为 ExpressionPattern 并注册到 ExpressionRegistry。
+
+    加载流程：
+        1. 检查目录是否存在，不存在则返回空 Registry
+        2. 遍历目录下的所有 YAML 文件（按文件名排序）
+        3. 读取并解析每个 YAML 文件
+        4. 验证必需字段（name, regex）
+        5. 创建 ExpressionPattern 对象
+        6. 注册到 Registry
+
+    :param base_dir: 包含 .yaml 规则文件的目录路径，可以是相对路径或绝对路径
+    :return: 填充了所有已加载规则的 ExpressionRegistry 实例
+
+    YAML 文件要求：
+        - 必须包含 name 字段：规则名称，用于唯一标识
+        - 必须包含 regex 字段：正则表达式字符串
+        - 可选包含 description 字段：描述信息
+        - 可选包含 output 字段：输出配置字典
+
+    错误处理：
+        - 无名称的规则文件会被跳过并输出警告
+        - 无正则的规则文件会被跳过并输出警告
+        - 加载失败的文件会输出错误信息并继续处理其他文件
+
+    示例：
+        >>> registry = load_patterns_from_config("data/patterns")
+        >>> print(f"已加载 {len(registry.patterns)} 条规则")
+    """
+    # 延迟导入 domain 层类型，避免 core 层在模块导入时反向依赖 domain
+    from app.shared.domain.expression_system import ExpressionPattern, ExpressionRegistry, create_templated_parser
+
+    # 创建空的 ExpressionRegistry 实例
+    # 用于存储所有加载的表达式模式
+    registry = ExpressionRegistry()
+
+    logger.debug(f"开始从 '{base_dir}' 加载表达式规则...")
+
+    # 检查目录是否存在
+    if not os.path.isdir(base_dir):
+        # 目录不存在，输出信息并返回空 Registry
+        logger.debug(f"目录不存在，跳过：'{base_dir}'")
+        return registry
+
+    # 遍历目录下的所有文件
+    # 使用 sorted() 确保加载顺序一致，便于调试和复现
+    for filename in sorted(os.listdir(base_dir)):
+        # 只处理 .yaml 和 .yml 文件
+        if filename.endswith((".yaml", ".yml")):
+            # 拼接完整的文件路径
+            filepath = os.path.join(base_dir, filename)
+
+            try:
+                # 读取 YAML 文件内容
+                cfg = read_yaml(Path(filepath))
+
+                # 提取并验证 name 字段
+                name = cfg.get("name")
+                if not name:
+                    logger.warning(f"跳过无名称的规则文件：{filename}")
+                    continue
+
+                # 提取并验证 regex 字段
+                regex_str = cfg.get("regex")
+                if not regex_str:
+                    logger.warning(f"跳过无正则的规则文件：{filename}")
+                    continue
+
+                # 创建模板化解析器工厂函数
+                # output 字段可选，用于配置解析器的输出格式
+                parser_factory = create_templated_parser(cfg.get("output") or {})
+
+                # 编译正则表达式为 Pattern 对象
+                # 使用 re.compile 提高后续匹配的效率
+                pattern = ExpressionPattern(name=name, regex=re.compile(regex_str), parser_func=parser_factory)
+
+                # 将模式注册到 Registry
+                registry.register(pattern)
+
+                logger.debug(f"成功加载并注册了模板化表达式：'{name}'")
+
+            except Exception as e:
+                # 捕获加载过程中的所有异常
+                # 输出错误信息但继续处理其他文件
+                logger.warning(f"加载规则文件 '{filename}' 失败: {e}")
+
+    logger.debug("表达式规则加载完成。")
+
+    # 返回填充了规则的 Registry 实例
+    return registry

app/shared/core/patterns/writer.py

@@ -0,0 +1,244 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+r"""
+@fileoverview Pattern YAML 写入模块
+
+功能概述:
+- 将 Pattern 数据模型序列化为 YAML 文件并写入 patterns/ 目录
+- 支持自动创建目录和生成安全的文件名
+- 提供 Pattern 存在性检查和唯一名称生成功能
+
+架构设计:
+- 数据验证: 使用 Pydantic BaseModel 确保 Pattern 数据符合规范
+- 安全写入: 使用 write_yaml 进行安全的 YAML 序列化
+- 文件名处理: 自动清理不合法字符，解决命名冲突
+
+PatternFile 数据模型:
+    name: str - Pattern 名称（必需）
+    regex: str - 正则表达式（必需）
+    description: Optional[str] - 描述信息（可选）
+    output: Optional[Dict[str, Any]] - 输出配置（可选）
+
+使用示例:
+    # 保存 Pattern 文件
+    pattern = PatternFile(name="email", regex=r"[\w\.]+@[\w\.]+", description="邮箱验证")
+    filepath = save_pattern_file(pattern, "patterns")
+
+    # 检查是否存在
+    exists = check_pattern_exists("patterns", "email")
+
+    # 生成唯一名称
+    unique_name = generate_unique_pattern_name("patterns", "email")
+"""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+from ..io.yaml import write_yaml_atomic
+
+
+class PatternFile(BaseModel):
+    """
+    Pattern 文件格式的数据模型。
+
+    使用 Pydantic 进行数据验证，确保写入的 Pattern 数据符合规范。
+    所有字段都有描述信息，便于文档生成和 IDE 提示。
+
+    字段说明：
+        name: Pattern 的唯一标识名称，用于在 Registry 中检索
+        regex: 正则表达式字符串，定义匹配规则
+        description: 可选的描述信息，说明 Pattern 的用途
+        output: 可选的输出配置，定义解析器的输出格式
+    """
+
+    # Pattern 名称，用于唯一标识
+    name: str = Field(..., description="Pattern 名称")
+
+    # 正则表达式字符串
+    regex: str = Field(..., description="正则表达式")
+
+    # 可选的描述信息
+    description: str | None = Field(None, description="描述信息")
+
+    # 可选的输出配置字典
+    output: dict[str, Any] | None = Field(None, description="输出配置")
+
+
+def save_pattern_file(pattern: PatternFile, patterns_dir: str, filename: str | None = None) -> str:
+    r"""
+    保存 Pattern 文件到 patterns 目录。
+
+    将 PatternFile 对象序列化为 YAML 格式并写入文件。
+    支持自动生成安全的文件名，并创建必要的目录。
+
+    :param pattern: Pattern 数据模型对象
+    :param patterns_dir: patterns 目录路径
+    :param filename: 可选的文件名，默认使用 pattern.name + ".yaml"
+    :return: 保存的文件完整路径
+
+    处理流程：
+        1. 确定文件名（如果未提供，从 pattern.name 生成）
+        2. 创建 patterns_dir 目录（如果不存在）
+        3. 拼接完整的文件路径
+        4. 使用 Pydantic model_dump 导出数据
+        5. 调用 write_yaml 写入文件
+
+    文件名安全处理：
+        - 只保留字母、数字、短横线(-)和下划线(_)
+        - 其他字符替换为下划线(_)
+        - 例如："My Pattern!" 转换为 "My_Pattern_.yaml"
+
+    示例：
+        >>> pattern = PatternFile(name="phone", regex=r"\d{3}-\d{4}")
+        >>> filepath = save_pattern_file(pattern, "data/patterns")
+        >>> print(f"已保存到: {filepath}")
+    """
+    # 如果未提供文件名，从 pattern.name 生成安全的文件名
+    if filename is None:
+        # 安全处理：将不合法字符替换为下划线
+        # isalnum(): 检查字符是否为字母或数字
+        safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in pattern.name)
+        filename = f"{safe_name}.yaml"
+
+    # 创建 patterns 目录（如果不存在）
+    # exist_ok=True: 如果目录已存在，不抛出异常
+    os.makedirs(patterns_dir, exist_ok=True)
+
+    # 拼接完整的文件路径
+    filepath = os.path.join(patterns_dir, filename)
+
+    # 使用 Pydantic 导出数据，排除 None 值
+    # exclude_none=True: 不写入值为 None 的字段
+    data = pattern.model_dump(exclude_none=True)
+
+    # 调用 write_yaml 写入文件
+    write_yaml_atomic(Path(filepath), data)
+
+    # 返回完整的文件路径
+    return filepath
+
+
+def check_pattern_exists(patterns_dir: str, pattern_name: str) -> bool:
+    """
+    检查指定名称的 Pattern 文件是否已存在。
+
+    用于判断是否需要创建新文件，或者是否会覆盖已有文件。
+
+    :param patterns_dir: patterns 目录路径
+    :param pattern_name: Pattern 名称
+    :return: 如果文件存在返回 True，否则返回 False
+
+    处理流程：
+        1. 检查 patterns_dir 是否为有效目录
+        2. 从 pattern_name 生成安全的文件名
+        3. 检查文件是否存在
+
+    文件名生成规则与 save_pattern_file 一致：
+        - 只保留字母、数字、短横线和下划线
+        - 其他字符替换为下划线
+
+    示例：
+        >>> if check_pattern_exists("patterns", "email"):
+        ...     print("Pattern 已存在")
+        ... else:
+        ...     print("可以创建新 Pattern")
+    """
+    # 检查目录是否存在
+    if not os.path.isdir(patterns_dir):
+        # 目录不存在，Pattern 文件必然不存在
+        return False
+
+    # 生成安全的文件名
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in pattern_name)
+
+    # 拼接文件路径
+    filepath = os.path.join(patterns_dir, f"{safe_name}.yaml")
+
+    # 检查文件是否存在并返回结果
+    return os.path.isfile(filepath)
+
+
+def generate_unique_pattern_name(patterns_dir: str, base_name: str) -> str:
+    """
+    生成唯一的 Pattern 名称，处理命名冲突。
+
+    如果 base_name 已存在，会自动在名称后添加数字后缀，
+    直到找到不冲突的名称。例如：email, email_1, email_2, ...
+
+    :param patterns_dir: patterns 目录路径
+    :param base_name: 基础名称
+    :return: 唯一的名称（如果基础名称可用则返回原名称，否则返回带数字后缀的名称）
+
+    处理流程：
+        1. 首先检查 base_name 是否可用
+        2. 如果不可用，从 1 开始递增尝试
+        3. 找到第一个不存在的名称后返回
+
+    示例：
+        >>> generate_unique_pattern_name("patterns", "email")
+        'email'  # 如果 email 不存在
+
+        >>> generate_unique_pattern_name("patterns", "email")
+        'email_3'  # 如果 email, email_1, email_2 都已存在
+    """
+    # 首先检查基础名称是否可用
+    if not check_pattern_exists(patterns_dir, base_name):
+        return base_name
+
+    # 基础名称已存在，从 1 开始尝试
+    counter = 1
+
+    # 循环尝试，直到找到不存在的名称
+    while True:
+        # 生成带数字后缀的名称
+        new_name = f"{base_name}_{counter}"
+
+        # 检查新名称是否可用
+        if not check_pattern_exists(patterns_dir, new_name):
+            return new_name
+
+        # 继续尝试下一个数字
+        counter += 1
+
+
+def get_pattern_filepath(patterns_dir: str, pattern_name: str) -> str:
+    """根据 pattern 名称推导其文件路径（与 save 的命名规则一致）。
+
+    :param patterns_dir: patterns 目录路径
+    :param pattern_name: Pattern 名称
+    :return: 完整文件路径
+    """
+    safe_name = "".join(c if c.isalnum() or c in "-_" else "_" for c in pattern_name)
+    return os.path.join(patterns_dir, f"{safe_name}.yaml")
+
+
+def delete_pattern_file(patterns_dir: str, pattern_name: str) -> bool:
+    """删除指定 Pattern 文件。
+
+    :param patterns_dir: patterns 目录路径
+    :param pattern_name: Pattern 名称
+    :return: 删除成功返回 True，文件不存在返回 False
+    """
+    filepath = get_pattern_filepath(patterns_dir, pattern_name)
+    if not os.path.isfile(filepath):
+        return False
+    os.remove(filepath)
+    return True

app/shared/core/project/__init__.py

@@ -0,0 +1,47 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""
+@fileoverview 项目配置模块（V2）统一入口
+
+功能概述:
+- 聚合导出项目加载的核心类型与入口函数
+- 对外提供统一的 load_project 加载接口
+- 作为 app.shared.core.project 包的门面（Facade），隐藏内部子模块细节
+
+架构设计:
+- 门面模式: 将 loader、types 等子模块的实现细节封装在内部，
+  调用方只需导入本模块即可获得全部所需功能，降低耦合度。
+- 类型重导出: LoadedProject、LoadingError 等核心类型从底层子模块
+  重新导出，避免调用方直接依赖内部文件路径，便于后续重构。
+
+导入路径简化示例:
+    >>> from app.shared.core.project import load_project, LoadedProject
+    >>> project = load_project(Path("project.precis.yaml"))
+    >>> print(project.schemas)
+
+注意事项:
+- 若需新增对外暴露的类型或函数，应在本模块执行重导出，
+  并在 __all__ 中补充对应名称以保持显式控制。
+- 禁止在本模块编写具体业务逻辑，所有实现应下沉到子模块中。
+"""
+
+# 从 loader 子模块导入核心类型和入口函数
+# 采用相对导入，保持包内引用的一致性
+from .loader import LoadedProject, load_project
+
+# __all__ 控制 `from app.shared.core.project import *` 时导出的名称列表
+# 显式列出公开 API，避免意外暴露内部辅助函数或子模块
+__all__ = ["load_project", "LoadedProject"]

app/shared/core/project/constraint/builders/__init__.py

@@ -0,0 +1,50 @@
+# SPDX-License-Identifier: Apache-2.0
+#
+# Copyright 2026 Precis Team
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+"""@fileoverview 约束构建器子包
+
+通过 side-effect import 触发各 builder 的 @register_builder 注册。
+新增约束类型时，新建 builder 文件并在本文件 import 即可自动注册。
+
+注册清单：
+- single_column: NotNull / AllowedValues / DateLogic / Range / Charset
+- unique: Unique（多列 list 语义）
+- foreign_key: ForeignKey（双向引用）
+- conditional: Conditional（IF 条件列表）
+- scripted: Scripted（可选列）
+- composite: Composite（递归子约束）
+"""
+
+from __future__ import annotations
+
+# side-effect import：触发各模块顶层的 @register_builder 调用
+from . import (  # noqa: F401
+    composite,
+    conditional,
+    foreign_key,
+    scripted,
+    single_column,
+    unique,
+)
+from .base import BuilderInput, BuilderResult
+from .registry import CONSTRAINT_BUILDERS, build_kwargs, register_builder
+
+__all__ = [
+    "BuilderInput",
+    "BuilderResult",
+    "CONSTRAINT_BUILDERS",
+    "build_kwargs",
+    "register_builder",
+]