precis-cli 0.1.3__py3-none-any.whl

app/shared/services/llm/constraints/frontend_instructions.py

@@ -0,0 +1,333 @@
+# 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、Regex、Transform、Settings 全部操作
+- 统一指令格式，便于前端 dispatcher 分发处理
+- 约束指令的 targetNodeId 走与写 YAML 相同的名称→ID fallback 解析，
+  保证"写文件"和"生成前端指令"两条出口的 ID 解析能力对等
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from app.shared.services.llm.constraints.constraint_id import _generate_constraint_id
+from app.shared.services.llm.schema_resolver import _resolve_id_from_name
+from app.shared.services.llm.suggestion_utils import normalize_constraint_type
+
+logger = logging.getLogger(__name__)
+
+
+def _read_yaml_file(path: Path) -> dict[str, Any] | None:
+    """安全读取 YAML 文件，失败返回 None（仅用于 UPDATE 指令重读磁盘真实结果）。"""
+    try:
+        if not path.exists():
+            return None
+        with open(path, encoding="utf-8") as f:
+            return yaml.safe_load(f) or {}
+    except Exception as e:
+        logger.warning(f"[frontend_instructions] 重读文件失败 {path}: {e}")
+        return None
+
+
+# 动作分类集合从注册表派生（单一事实源），避免本地硬编码与注册表不同步
+from app.shared.services.llm.actions.registry import (
+    CONSTRAINT_ACTION_TYPES,
+    REGEX_ACTION_TYPES,
+    SCHEMA_ACTION_TYPES,
+    TRANSFORM_ACTION_TYPES,
+)
+
+
+def generate_frontend_instructions(action: dict[str, Any], workspace_path: str = "") -> dict[str, Any]:
+    """
+    @methoddesc 生成前端渲染指令（通用入口）
+
+    根据 actionType 分发到对应的指令生成器。
+    workspace_path 用于约束指令的名称→ID fallback 解析，
+    保证 targetNodeId 与写 YAML 路径使用同一套解析逻辑。
+
+    参数:
+        action: 动作字典，包含 actionType 和对应的 spec
+        workspace_path: 项目工作区路径，启用约束指令的 ID 解析（默认空=原样透传）
+
+    返回:
+        前端渲染指令字典
+    """
+    action_type = action.get("actionType", "")
+
+    if action_type in CONSTRAINT_ACTION_TYPES:
+        return _generate_constraint_instruction(action, workspace_path)
+    elif action_type in SCHEMA_ACTION_TYPES:
+        return _generate_schema_instruction(action, workspace_path)
+    elif action_type in REGEX_ACTION_TYPES:
+        return _generate_regex_instruction(action, workspace_path)
+    elif action_type in TRANSFORM_ACTION_TYPES:
+        return _generate_transform_instruction(action, workspace_path)
+    elif action_type == "UPDATE_SETTINGS":
+        return _generate_settings_instruction(action)
+    elif action_type == "ADD_TO_CANVAS":
+        return _generate_canvas_instruction(action, workspace_path)
+    else:
+        return {"actionType": action_type}
+
+
+def _generate_constraint_instruction(action: dict[str, Any], workspace_path: str = "") -> dict[str, Any]:
+    """
+    生成约束类前端指令
+
+    与 _build_constraint_refs 保持对等的 ID 解析能力：
+    当 targetNodeId 为空或可疑时，用 _resolve_id_from_name 从 schema 文件
+    解析出确定性的 table_id / column_id，避免前端拿到 AI 原话找不到节点。
+    """
+    action_type = action.get("actionType")
+    constraint_spec = action.get("constraintSpec", {})
+
+    # 标准化为 PascalCase 正名再下发：提示词教 AI 输出 PascalCase（NotNull），
+    # 但 LLM 也可能回大写下划线（NOT_NULL）。写盘路径已做同样的标准化，
+    # 此处对齐可保证前端指令与已写入的约束文件类型一致，避免前端拿到
+    # 自己无法识别的类型字符串而静默不建节点（幽灵约束）。
+    constraint_type = normalize_constraint_type(constraint_spec.get("type", ""))
+    target_node_id = constraint_spec.get("targetNodeId", "")
+    target_column_id = constraint_spec.get("targetColumnId", "")
+    table_name = constraint_spec.get("tableName", "")
+    target_column = constraint_spec.get("targetColumn", "")
+    is_inline = constraint_spec.get("isInline", False)
+    # params 原样透传（min/max/allowedValues/expression/toTableId 等）：
+    # 前端建独立约束节点时须据此填充节点 data，否则保存链路会用空 params
+    # 覆盖后端已写入的参数（静默数据丢失）。
+    params = constraint_spec.get("params", {})
+
+    # 关键：与写 YAML 路径（_build_constraint_refs）相同的 fallback 解析
+    # 当 workspace_path 可用时，把 tableName/targetColumn 解析为确定性的 schema/column ID
+    if workspace_path and table_name:
+        fallback_table_id, fallback_column_id = _resolve_id_from_name(
+            workspace_path, table_name, target_column or target_column_id
+        )
+        # 仅在 AI 未给出明确 ID、或给出空值时，用 fallback 覆盖
+        # （AI 明确给出的非空 ID 优先，尊重其意图）
+        if fallback_table_id and not target_node_id:
+            target_node_id = fallback_table_id
+        if fallback_column_id and not target_column_id:
+            target_column_id = fallback_column_id
+
+    filename_table = table_name or target_node_id or "unknown"
+    filename_column = target_column or target_column_id or "unknown"
+
+    constraint_id = _generate_constraint_id(constraint_type, filename_table or "inline", filename_column)
+
+    return {
+        "actionType": action_type,
+        "constraintSpec": {
+            "type": constraint_type,
+            "targetNodeId": target_node_id,
+            "targetColumnId": target_column_id,
+            "tableName": table_name,
+            "targetColumn": target_column,
+            "constraintId": constraint_id,
+            "isInline": is_inline,
+            "params": params,
+        },
+    }
+
+
+def _generate_schema_instruction(action: dict[str, Any], workspace_path: str = "") -> dict[str, Any]:
+    """生成 Schema 类前端指令。
+
+    ADD：回声输入（输入即落盘结果）。
+    UPDATE：重读磁盘，返回合并后的真实完整列/源（避免回声仅含 LLM 增量导致画布丢列）。
+    DELETE：只需 id/name 用于前端定位，不重读（文件已删）。
+    """
+    action_type = action.get("actionType")
+    spec = action.get("schemaSpec", {})
+    schema_id = spec.get("schemaId") or spec.get("id", "")
+    name = spec.get("name", "")
+
+    columns = spec.get("columns", [])
+    source = spec.get("source")
+
+    # UPDATE 时重读磁盘真实结果（_update_schema 会保留未列出的列，回声会丢列）
+    if action_type == "UPDATE_SCHEMA" and workspace_path:
+        schemas_dir = Path(workspace_path) / "schemas"
+        # 按与 handler 一致的方式定位文件：先按 id，再按 name
+        candidates = list(schemas_dir.glob("*.yaml")) if schemas_dir.exists() else []
+        for sf in candidates:
+            data = _read_yaml_file(sf)
+            if data and (data.get("id") == schema_id or (name and data.get("name") == name)):
+                columns = data.get("columns", columns)
+                source = data.get("source", source)
+                break
+
+    return {
+        "actionType": action_type,
+        "schemaSpec": {
+            "name": name,
+            "schemaId": schema_id,
+            "columns": columns,
+            "source": source,
+        },
+    }
+
+
+def _generate_regex_instruction(action: dict[str, Any], workspace_path: str = "") -> dict[str, Any]:
+    """生成 Regex 类前端指令。
+
+    ADD：回声输入。UPDATE：重读磁盘真实 pattern/matchMode 等（整段替换，回声≈结果，重读为一致性）。
+    DELETE：只需 id/name 定位，不重读。
+    """
+    action_type = action.get("actionType")
+    spec = action.get("regexSpec", {})
+    regex_id = spec.get("regexId") or spec.get("id", "")
+    name = spec.get("name", "")
+
+    pattern = spec.get("pattern", "")
+    match_mode = spec.get("matchMode", "full")
+    case_sensitive = spec.get("caseSensitive", False)
+    description = spec.get("description")
+
+    if action_type == "UPDATE_REGEX" and workspace_path and regex_id:
+        data = _read_yaml_file(Path(workspace_path) / "regex" / f"{regex_id}.regex.yaml")
+        if data:
+            pattern = data.get("pattern", pattern)
+            match_mode = data.get("matchMode", match_mode)
+            case_sensitive = data.get("caseSensitive", case_sensitive)
+            description = data.get("description", description)
+
+    return {
+        "actionType": action_type,
+        "regexSpec": {
+            "name": name,
+            "regexId": regex_id,
+            "pattern": pattern,
+            "matchMode": match_mode,
+            "caseSensitive": case_sensitive,
+            "targetNodeId": spec.get("targetNodeId"),
+            "targetColumn": spec.get("targetColumn"),
+            "description": description,
+        },
+    }
+
+
+def _generate_transform_instruction(action: dict[str, Any], workspace_path: str = "") -> dict[str, Any]:
+    """生成 Transform 类前端指令。
+
+    ADD：回声输入。UPDATE：重读磁盘真实 params 等（整段替换，回声≈结果，重读为一致性）。
+    DELETE：只需 id 定位，不重读。
+    """
+    action_type = action.get("actionType")
+    spec = action.get("transformSpec", {})
+    transform_id = spec.get("transformId") or spec.get("id", "")
+
+    params = spec.get("params", {})
+    output_columns = spec.get("outputColumns", [])
+    description = spec.get("description")
+
+    if action_type == "UPDATE_TRANSFORM" and workspace_path and transform_id:
+        data = _read_yaml_file(Path(workspace_path) / "transforms" / f"{transform_id}.transform.yaml")
+        if data:
+            params = data.get("params", params)
+            output_columns = data.get("outputColumns", output_columns)
+            description = data.get("description", description)
+
+    return {
+        "actionType": action_type,
+        "transformSpec": {
+            "transformId": transform_id,
+            "type": spec.get("type", ""),
+            "description": description,
+            "inputFromNode": spec.get("inputFromNode"),
+            "inputColumn": spec.get("inputColumn"),
+            "params": params,
+            "outputColumns": output_columns,
+        },
+    }
+
+
+def _generate_settings_instruction(action: dict[str, Any]) -> dict[str, Any]:
+    """生成 Settings 类前端指令"""
+    action_type = action.get("actionType")
+    spec = action.get("settingsSpec", {})
+    return {
+        "actionType": action_type,
+        "settingsSpec": {
+            "category": spec.get("category", ""),
+            "settings": spec.get("settings", {}),
+        },
+    }
+
+
+def _generate_canvas_instruction(action: dict[str, Any], workspace_path: str = "") -> dict[str, Any]:
+    """生成 ADD_TO_CANVAS 前端指令（重读磁盘真实配置）
+
+    与 ADD_*（回声输入）不同：ADD_TO_CANVAS 的语义是"显示已存在的配置到画布"，
+    故重读磁盘拿到真实数据（columns/source/pattern 等），保证画布显示与配置一致，
+    而非依赖 LLM 输入（可能不完整或与磁盘不同步）。
+
+    前端收到后委托 graphStore.importV2ResourceToCanvas 创建节点（幂等）。
+    """
+    spec = action.get("canvasSpec", {})
+    resource_kind = spec.get("resourceKind", "")
+    resource_id = spec.get("resourceId", "")
+    resource_name = spec.get("resourceName") or spec.get("name", "")
+
+    # 定位磁盘配置文件并重读真实数据
+    # dir_map 与 _canvas_validator._list_existing_resource_ids 保持一致
+    dir_map = {
+        "schema": ("schemas", "*.schema.yaml"),
+        "regex": ("regex", "*.regex.yaml"),
+        "constraint": ("constraints", "*.constraint.yaml"),
+        "transform": ("transforms", "*.transform.yaml"),
+    }
+    real_config: dict[str, Any] = {}
+    if workspace_path and resource_kind in dir_map:
+        subdir, pattern = dir_map[resource_kind]
+        target_dir = Path(workspace_path) / subdir
+        if target_dir.exists():
+            for f in target_dir.glob(pattern):
+                data = _read_yaml_file(f)
+                if not data:
+                    continue
+                # 按 id 或 name 匹配目标资源
+                fid = data.get("id", "")
+                fname = data.get("name", "")
+                if (resource_id and str(fid) == str(resource_id)) or (
+                    resource_name and str(fname) == str(resource_name)
+                ):
+                    real_config = data
+                    # 同步补全 resourceId（若 LLM 只给了 name）
+                    if not resource_id and fid:
+                        resource_id = str(fid)
+                    break
+
+    return {
+        "actionType": "ADD_TO_CANVAS",
+        "canvasSpec": {
+            "resourceKind": resource_kind,
+            "resourceId": resource_id,
+            "name": resource_name,
+            # 透传重读的真实配置，前端可据此直接构建节点（importV2ResourceToCanvas 也会独立重读，
+            # 但携带 config 可让前端在不依赖 API 往返时也能渲染）
+            "config": real_config,
+        },
+    }

app/shared/services/llm/constraints/inline_batch.py

@@ -0,0 +1,279 @@
+# 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 的多个内联约束
+- 核心优化：只读取和写入 schema 文件一次，避免多次 IO
+- 所有约束先在内存中处理，最后统一原子性写入
+
+输入示例:
+    results = process_inline_batch(actions, "/workspace")
+
+输出示例:
+    [
+        {"action": action, "success": True, "message": "inline:notnull_users_email", "frontendInstructions": {...}},
+        ...
+    ]
+"""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import yaml
+
+from app.shared.services.llm.constraints.constraint_builder import (
+    CONSTRAINT_TYPE_MAP,
+    _build_constraint_params,
+)
+from app.shared.services.llm.constraints.constraint_id import _generate_constraint_id
+from app.shared.services.llm.constraints.frontend_instructions import generate_frontend_instructions
+from app.shared.services.llm.yaml_io import FileLock, atomic_write_yaml
+
+logger = logging.getLogger(__name__)
+
+
+def _collect_target_schema_id(action: dict[str, Any]) -> str | None:
+    """
+    @methoddesc 从 action 中提取目标 schema ID（用于批量处理时分组）
+
+    参数:
+        action: 动作字典
+
+    返回:
+        schema ID 字符串，如果无法识别则返回 None
+    """
+    spec = action.get("constraintSpec", {})
+    # 优先使用 tableName，其次是 targetNodeId
+    value = spec.get("tableName") or spec.get("targetNodeId")
+    return value if isinstance(value, str) else None
+
+
+def _is_inline_action(action: dict[str, Any]) -> bool:
+    """
+    @methoddesc 判断动作是否为内联约束操作
+
+    内联约束直接存储在 schema 文件中，而非独立的 .constraint.yaml 文件。
+
+    参数:
+        action: 动作字典
+
+    返回:
+        True 表示内联约束，False 表示独立约束
+    """
+    spec = action.get("constraintSpec", {})
+    return bool(spec.get("isInline", False))
+
+
+def process_inline_batch(actions: list[dict[str, Any]], workspace_path: str) -> list[dict[str, Any]]:
+    """
+    @methoddesc 批量处理同一 schema 的多个内联约束
+
+    核心优化：只读取和写入 schema 文件一次，避免多个独立约束操作导致多次 IO。
+    所有约束先在内存中处理，最后统一原子性写入。
+
+    参数:
+        actions: 同一 schema 的内联约束操作列表
+        workspace_path: 项目工作区路径
+
+    返回:
+        每个 action 的处理结果列表
+
+    示例:
+        >>> results = process_inline_batch([
+        ...     {"actionType": "ADD_CONSTRAINT_NODE", "constraintSpec": {"isInline": True, ...}},
+        ...     {"actionType": "ADD_CONSTRAINT_NODE", "constraintSpec": {"isInline": True, ...}},
+        ... ], "/workspace")
+    """
+    if not actions:
+        return []
+
+    # 从第一个 action 中提取 schema 标识（假设同一批的 schema 相同）
+    first_action = actions[0]
+    spec = first_action.get("constraintSpec", {})
+    target_node_id = spec.get("targetNodeId", "")
+    table_name = spec.get("tableName", "")
+    target_table_id = target_node_id or table_name
+
+    results = []
+
+    try:
+        schemas_dir = Path(workspace_path) / "schemas"
+        schema_file = None
+
+        # 在 schemas 目录中查找匹配的 schema 文件
+        for sf in schemas_dir.glob("*.yaml"):
+            with open(sf, encoding="utf-8") as f:
+                sd = yaml.safe_load(f) or {}
+            if sd.get("id") == target_table_id or sd.get("name") == table_name:
+                schema_file = sf
+                break
+
+        if not schema_file:
+            # schema 文件不存在，所有操作标记为失败
+            for action in actions:
+                results.append(
+                    {
+                        "action": action,
+                        "success": False,
+                        "message": f"未找到 schema 文件: {target_table_id}",
+                        "frontendInstructions": None,
+                    }
+                )
+            return results
+
+        # 使用文件锁保护，一次性处理所有约束
+        with FileLock(str(schema_file)):
+            # 重新读取文件（确保获取最新内容）
+            with open(schema_file, encoding="utf-8") as f:
+                schema_data = yaml.safe_load(f) or {}
+
+            columns = schema_data.get("columns", [])
+            if "constraints" not in schema_data:
+                schema_data["constraints"] = []
+
+            # 逐个处理约束（全部在内存中修改，不立即写入）
+            has_delete = False
+            for action in actions:
+                try:
+                    spec = action.get("constraintSpec", {})
+                    action_type = action.get("actionType", "")
+                    constraint_type = spec.get("type", "")
+                    target_column = spec.get("targetColumn", "")
+                    target_column_id = spec.get("targetColumnId", "")
+
+                    # 将约束类型别名标准化
+                    std_type = CONSTRAINT_TYPE_MAP.get(constraint_type, constraint_type)
+
+                    # 查找目标列的 ID（优先使用传入的 ID，否则按名称查找）
+                    column_id = target_column_id
+                    if not column_id:
+                        for col in columns:
+                            if col.get("name") == target_column:
+                                column_id = col.get("id")
+                                break
+
+                    if not column_id:
+                        results.append(
+                            {
+                                "action": action,
+                                "success": False,
+                                "message": f"未找到列 ID: {target_column}",
+                                "frontendInstructions": None,
+                            }
+                        )
+                        continue
+
+                    # 生成约束 ID
+                    filename_table = table_name or target_node_id or "unknown"
+                    constraint_id = _generate_constraint_id(std_type, filename_table, target_column)
+
+                    # DELETE 动作：从内存中的 constraints 移除「同列 + 同类型」项，绝不新增。
+                    # 旧实现不区分 actionType，删除动作会被当作添加处理（只增不删还报成功）。
+                    if action_type == "DELETE_CONSTRAINT_NODE":
+                        has_delete = True
+                        remaining = [
+                            c
+                            for c in schema_data["constraints"]
+                            if not (c.get("column") == column_id and c.get("type") == std_type)
+                        ]
+                        if len(remaining) == len(schema_data["constraints"]):
+                            results.append(
+                                {
+                                    "action": action,
+                                    "success": False,
+                                    "message": f"未找到内联约束: {std_type} on {filename_table}.{target_column}",
+                                    "frontendInstructions": None,
+                                }
+                            )
+                            continue
+                        schema_data["constraints"] = remaining
+                        logger.info(f"[批量处理] 删除内联约束: {constraint_id}")
+                        results.append(
+                            {
+                                "action": action,
+                                "success": True,
+                                "message": f"inline:{constraint_id}",
+                                "frontendInstructions": generate_frontend_instructions(action, workspace_path),
+                            }
+                        )
+                        continue
+
+                    # 构建内联约束结构（字段与其他约束保持一致）
+                    constraint_description = spec.get("description") or f"{constraint_id}"
+                    inline_constraint = {
+                        "id": constraint_id,
+                        "column": column_id,
+                        "type": std_type,
+                        "enabled": True,
+                        "description": constraint_description,
+                    }
+                    params = _build_constraint_params(std_type, spec)
+                    if params:
+                        inline_constraint["params"] = params
+
+                    # 检查是否已存在相同列和类型的约束
+                    existing_idx = None
+                    for idx, existing in enumerate(schema_data["constraints"]):
+                        if existing.get("column") == column_id and existing.get("type") == std_type:
+                            existing_idx = idx
+                            break
+
+                    if existing_idx is not None:
+                        # 更新现有约束
+                        schema_data["constraints"][existing_idx] = inline_constraint
+                        logger.info(f"[批量处理] 更新内联约束: {constraint_id}")
+                    else:
+                        # 添加新约束
+                        schema_data["constraints"].append(inline_constraint)
+                        logger.info(f"[批量处理] 添加内联约束: {constraint_id}")
+
+                    results.append(
+                        {
+                            "action": action,
+                            "success": True,
+                            "message": f"inline:{constraint_id}",
+                            "frontendInstructions": generate_frontend_instructions(action, workspace_path),
+                        }
+                    )
+
+                except Exception as e:
+                    logger.error(f"[批量处理] 处理约束失败: {e}")
+                    results.append(
+                        {"action": action, "success": False, "message": str(e), "frontendInstructions": None}
+                    )
+
+            # 只要有成功的操作，就一次性写入所有修改
+            if any(r["success"] for r in results):
+                # 含删除动作时必须全量替换写入：atomic_write_yaml 的 preserve_format
+                # 路径按 id 合并列表（只更新/追加、不删除），会把已删除的约束"复活"
+                atomic_write_yaml(schema_file, schema_data, preserve_format=not has_delete)
+                logger.info(f"[批量处理] 成功保存 {len([r for r in results if r['success']])} 个约束到 schema")
+
+    except Exception as e:
+        logger.error(f"[批量处理] 批量处理失败: {e}")
+        # 为尚未记录结果的操作标记为失败
+        for i, action in enumerate(actions):
+            if len(results) < i + 1:
+                results.append(
+                    {"action": action, "success": False, "message": f"批量处理失败: {e}", "frontendInstructions": None}
+                )
+
+    return results

app/shared/services/llm/discovery/__init__.py

@@ -0,0 +1,35 @@
+# 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 LLM 服务发现模块入口
+
+功能概述:
+- 导出本地 LLM 服务扫描相关类（ServiceScanner、DiscoveredService）
+- 供 API 层调用以自动发现本地运行的 AI 服务
+
+架构设计:
+- 聚合导出 scanner.py 中的公共类和全局实例
+- 通过 __all__ 控制对外暴露的接口
+
+输入示例:
+    from app.shared.services.llm.discovery import scanner, DiscoveredService
+
+输出示例:
+    services = await scanner.scan()
+"""
+
+from .scanner import DiscoveredService, ServiceScanner, scanner
+
+__all__ = ["ServiceScanner", "DiscoveredService", "scanner"]