data-ops-cli 0.5.1__tar.gz → 0.5.2__tar.gz

{data_ops_cli-0.5.1 → data_ops_cli-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-ops-cli
-Version: 0.5.1
+Version: 0.5.2
 Summary: Command-line wrapper around dataops_sdk for the DataOps platform.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{data_ops_cli-0.5.1 → data_ops_cli-0.5.2}/src/data_ops_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: data-ops-cli
-Version: 0.5.1
+Version: 0.5.2
 Summary: Command-line wrapper around dataops_sdk for the DataOps platform.
 Requires-Python: >=3.11
 Description-Content-Type: text/markdown

{data_ops_cli-0.5.1 → data_ops_cli-0.5.2}/src/data_ops_cli.egg-info/SOURCES.txt

@@ -15,7 +15,6 @@ src/dataops_cli/sdk.py
 src/dataops_cli/session.py
 src/dataops_cli/utils.py
 src/dataops_cli/cli/__init__.py
-src/dataops_cli/cli/alarm.py
 src/dataops_cli/cli/api.py
 src/dataops_cli/cli/auth.py
 src/dataops_cli/cli/data_table.py
@@ -23,7 +22,6 @@ src/dataops_cli/cli/dataset.py
 src/dataops_cli/cli/datasource.py
 src/dataops_cli/cli/dict_.py
 src/dataops_cli/cli/factory.py
-src/dataops_cli/cli/hazard.py
 src/dataops_cli/cli/kb.py
 src/dataops_cli/cli/metrics.py
 src/dataops_cli/cli/ontology.py

{data_ops_cli-0.5.1 → data_ops_cli-0.5.2}/src/dataops_cli/__init__.py

@@ -14,4 +14,4 @@ groups command modules under :mod:`dataops_cli.cli` and re-exports the package
     removed in ``dataops_cli`` 1.0.
 """
 
-__version__ = "0.5.1"
+__version__ = "0.5.2"

{data_ops_cli-0.5.1 → data_ops_cli-0.5.2}/src/dataops_cli/cli/__init__.py

@@ -1,6 +1,6 @@
 """data-ops-cli 的 Typer 命令组集合.
 
-本包聚合所有 CLI 子命令模块（alarm、api、auth 等），由 ``factory.create_app``
+本包聚合所有 CLI 子命令模块（api、auth 等），由 ``factory.create_app``
 统一注册为 Typer 应用并通过 ``dataops_cli.cli.app`` 暴露。
 """
 

{data_ops_cli-0.5.1 → data_ops_cli-0.5.2}/src/dataops_cli/cli/factory.py

@@ -39,20 +39,18 @@ def main(
 def create_app():
     """组装并返回 data-ops-cli 的顶层 Typer 应用。
 
-    负责集中导入各业务子命令模块（alarm、api、auth 等），将其 Typer 子命令组
+    负责集中导入各业务子命令模块（api、auth 等），将其 Typer 子命令组
     注册到根应用上，并绑定 ``--version`` 回调。
 
     Returns:
         已注册所有子命令组的 ``typer.Typer`` 应用实例。
     """
-    from dataops_cli.cli.alarm import alarm_typer
     from dataops_cli.cli.api import api_typer
     from dataops_cli.cli.auth import auth_typer
     from dataops_cli.cli.data_table import data_table_typer
     from dataops_cli.cli.dataset import dataset_typer
     from dataops_cli.cli.datasource import datasource_typer
     from dataops_cli.cli.dict_ import dict_typer
-    from dataops_cli.cli.hazard import hazard_typer
     from dataops_cli.cli.kb import kb_typer
     from dataops_cli.cli.metrics import metrics_typer
     from dataops_cli.cli.ontology import ontology_typer
@@ -71,7 +69,6 @@ def create_app():
     )
     app.add_typer(auth_typer)
     app.add_typer(api_typer)
-    app.add_typer(alarm_typer)
     app.add_typer(datasource_typer)
     app.add_typer(dataset_typer)
     app.add_typer(table_typer)
@@ -84,7 +81,6 @@ def create_app():
     app.add_typer(data_table_typer)
     app.add_typer(widget_typer)
     app.add_typer(dict_typer)
-    app.add_typer(hazard_typer)
     app.add_typer(kb_typer)
     app.add_typer(tag_typer)
 

data_ops_cli-0.5.1/src/dataops_cli/cli/alarm.py

@@ -1,721 +0,0 @@
-"""告警管理模块.
-
-提供告警规则的查询与配置能力，覆盖后端 /alarm/rule/* 接口。
-
-- 服务层函数 (service_*)：纯 Python 接口，返回原始数据
-- CLI 命令：基于服务层的薄包装，负责格式化输出
-"""
-
-import json
-from typing import Annotated, Any
-
-import typer
-from dataops_sdk.exceptions import DataOpsError
-from dataops_sdk.services.alarm import (
-    service_count_alarm_action,
-    service_count_alarm_rule_matches,
-    service_count_alarm_rules,
-    service_count_alarm_specs,
-    service_find_alarm_table_data,
-    service_find_meta_by_codes,
-    service_get_alarm_action_detail,
-    service_get_alarm_builtin_function_detail,
-    service_get_alarm_preprocess_detail,
-    service_get_alarm_rule_detail,
-    service_get_alarm_rule_enums,
-    service_get_alarm_rule_type_detail,
-    service_get_alarm_spec_detail,
-    service_get_alarm_table_columns,
-    service_get_rel_table_columns,
-    service_list_alarm_action,
-    service_list_alarm_builtin_functions,
-    service_list_alarm_preprocess,
-    service_list_alarm_rule_matches,
-    service_list_alarm_rules,
-    service_list_alarm_specs,
-)
-from pydantic_core import to_json
-from rich.console import Console
-from rich.table import Table
-
-from dataops_cli.cli.utils import print_list
-
-# ---------------------------------------------------------------------------
-# CLI 命令（薄包装，负责输出渲染）
-# ---------------------------------------------------------------------------
-
-alarm_typer = typer.Typer(name="alarm", help="告警规则配置", no_args_is_help=True)
-alarm_rule_typer = typer.Typer(name="rule", help="告警规则命令", no_args_is_help=True)
-alarm_rule_type_typer = typer.Typer(name="type", help="告警规则类型命令", no_args_is_help=True)
-alarm_spec_typer = typer.Typer(name="spec", help="告警专业命令", no_args_is_help=True)
-alarm_action_typer = typer.Typer(name="action", help="告警动作命令", no_args_is_help=True)
-alarm_preprocess_typer = typer.Typer(name="preprocess", help="预处理脚本命令", no_args_is_help=True)
-alarm_builtin_function_typer = typer.Typer(
-    name="builtin-function", help="内置函数命令", no_args_is_help=True
-)
-rule_match_typer = typer.Typer(name="match", help="规则匹配命令", no_args_is_help=True)
-alarm_typer.add_typer(alarm_rule_typer, no_args_is_help=True)
-alarm_typer.add_typer(alarm_spec_typer, no_args_is_help=True)
-alarm_rule_typer.add_typer(alarm_rule_type_typer, no_args_is_help=True)
-alarm_rule_typer.add_typer(rule_match_typer, no_args_is_help=True)
-alarm_typer.add_typer(alarm_action_typer, no_args_is_help=True)
-alarm_typer.add_typer(alarm_preprocess_typer, no_args_is_help=True)
-alarm_typer.add_typer(alarm_builtin_function_typer, no_args_is_help=True)
-
-
-def _safe_str(value: Any) -> str:
-    if value is None:
-        return ""
-    if isinstance(value, (dict, list)):
-        return to_json(value).decode("utf-8")
-    return str(value)
-
-
-def _extract_column_list(data: Any) -> list:
-    """从响应中提取列数组。
-
-    后端返回可能是:
-    - list[...] 直接列表
-    - dict {"columns": [...], "indexes": [...]} 嵌套结构
-    - None / 其他 空
-    """
-    if isinstance(data, list):
-        return data
-    if isinstance(data, dict):
-        columns = data.get("columns")
-        if isinstance(columns, list):
-            return columns
-    return []
-
-
-def _print_column_list(data: Any) -> None:
-    """统一渲染列数组（list[dict] → 平面表；其他 → JSON）."""
-    columns = _extract_column_list(data)
-    if not columns:
-        print("(空)")
-        return
-    if isinstance(columns[0], dict):
-        headers = list(columns[0].keys())
-        rows = [[_safe_str(c.get(h)) for h in headers] for c in columns]
-        print_list(headers, rows)
-    else:
-        print(to_json(columns).decode("utf-8"))
-
-
-def _print_alarm_detail(detail: Any, title: str, simplify: bool = False) -> None:
-    """渲染告警详情的主体、data 和参数。"""
-    console = Console(no_color=True)
-    meta = detail.meta
-    basic_table = Table("字段", "值", title=title, show_header=False)
-    for field in ("code", "title", "type", "remark", "createUser", "lastModifyTime"):
-        value = getattr(meta, field, None)
-        if value is not None:
-            basic_table.add_row(field, _safe_str(value))
-    console.print(basic_table)
-
-    data = meta.data or {}
-    if hasattr(data, "model_dump"):
-        data = data.model_dump(mode="json")
-    if isinstance(data, dict):
-        data_table = Table("data 字段", "值", title="详情数据", show_header=False)
-        for key, value in data.items():
-            if simplify and key.lower() in {"script", "scriptcontent", "script_content"}:
-                continue
-            data_table.add_row(str(key), _safe_str(value))
-        if data_table.row_count:
-            console.print(data_table)
-
-    if detail.params:
-        params_table = Table("参数", "值", title="Meta 参数", show_header=False)
-        for key, value in detail.params.items():
-            params_table.add_row(str(key), _safe_str(value))
-        console.print(params_table)
-
-
-def _handle_alarm_detail(detail_service, code: str, title: str, simplify: bool) -> None:
-    """统一处理详情 service 的错误和终端输出。"""
-    try:
-        detail = detail_service(code)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-    _print_alarm_detail(detail, title, simplify)
-
-
-@alarm_preprocess_typer.command("list", help="查询预处理脚本")
-def list_alarm_preprocess(
-    spec_type: Annotated[
-        list[str] | None, typer.Option("--spec-type", help="关联专业编码，可重复传入")
-    ] = None,
-    enabled: Annotated[
-        list[str] | None, typer.Option("--enabled", help="启用状态值 1/0，可重复传入")
-    ] = None,
-    page_num: Annotated[int, typer.Option("-n", "--page-num", "--page", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", "--size", help="每页大小")] = 20,
-    query: Annotated[str | None, typer.Option("-q", "--query", help="脚本名称关键词")] = None,
-) -> None:
-    """查询预处理脚本列表。"""
-    try:
-        rows = service_list_alarm_preprocess(
-            page_num,
-            page_size,
-            query,
-            spec_type or [],
-            enabled or [],
-        )
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if not rows:
-        print("未查询到预处理脚本")
-        return
-    print_list(
-        ["脚本编码", "脚本名称", "关联专业", "脚本说明", "启用状态", "创建人", "创建时间"],
-        [
-            [
-                row.CODE,
-                row.TITLE,
-                row.N_SPEC_TYPE,
-                row.DESCRIPTION,
-                row.IS_ENABLED,
-                row.CREATE_USER,
-                row.CREATE_TIME,
-            ]
-            for row in rows
-        ],
-    )
-
-
-@alarm_preprocess_typer.command("detail", no_args_is_help=True)
-def get_alarm_preprocess_detail(
-    code: Annotated[str, typer.Argument(help="预处理脚本编码")],
-    simplify: Annotated[bool, typer.Option("-s", "--simplify", help="隐藏脚本正文")] = False,
-) -> None:
-    """按编码查询预处理脚本详情。"""
-    _handle_alarm_detail(
-        service_get_alarm_preprocess_detail,
-        code,
-        "预处理脚本详情",
-        simplify,
-    )
-
-
-@alarm_builtin_function_typer.command("list", help="查询内置函数")
-def list_alarm_builtin_functions(
-    enabled: Annotated[
-        list[str] | None, typer.Option("--enabled", help="启用状态值 1/0，可重复传入")
-    ] = None,
-    page_num: Annotated[int, typer.Option("-n", "--page-num", "--page", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", "--size", help="每页大小")] = 20,
-    query: Annotated[str | None, typer.Option("-q", "--query", help="函数名称关键词")] = None,
-) -> None:
-    """查询内置函数列表。"""
-    try:
-        rows = service_list_alarm_builtin_functions(page_num, page_size, query, enabled or [])
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if not rows:
-        print("未查询到内置函数")
-        return
-    print_list(
-        ["函数编码", "函数名称", "类全路径", "备注", "启用状态", "创建人", "创建时间"],
-        [
-            [
-                row.CODE,
-                row.TITLE,
-                row.CLAZZ,
-                row.REMARK,
-                row.IS_ENABLED,
-                row.CREATE_USER,
-                row.CREATE_TIME,
-            ]
-            for row in rows
-        ],
-    )
-
-
-@alarm_builtin_function_typer.command("detail", no_args_is_help=True)
-def get_alarm_builtin_function_detail(
-    code: Annotated[str, typer.Argument(help="内置函数编码")],
-    simplify: Annotated[bool, typer.Option("-s", "--simplify", help="隐藏函数脚本")] = False,
-) -> None:
-    """按编码查询内置函数详情。"""
-    _handle_alarm_detail(
-        service_get_alarm_builtin_function_detail,
-        code,
-        "内置函数详情",
-        simplify,
-    )
-
-
-@rule_match_typer.command("count", help="查询告警匹配规则数量")
-def count_alarm_rules_match(
-    spec: Annotated[list[str], typer.Option(help="专业值", default_factory=list)],
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警匹配规则数量。
-
-    按专业、关键字与启用状态进行过滤，返回匹配规则的总数。
-
-    Args:
-        spec: 专业值列表，多个值会同时参与匹配。
-        query: 可选关键字，用于模糊搜索。
-        enabled: 可选启用状态过滤；为 ``True`` / ``False`` 时严格匹配。
-
-    Examples:
-        >>> data-ops-cli alarm rule match count --spec MY_SPEC
-    """
-    try:
-        total = service_count_alarm_rule_matches(query, enabled, spec)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-    print(total)
-
-
-@rule_match_typer.command("list", help="查询告警匹配规则")
-def list_alarm_rules_match(
-    spec: Annotated[list[str], typer.Option(help="专业值", default_factory=list)],
-    page_num: Annotated[int, typer.Option("-n", "--page-num", "--page", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", "--size", help="每页大小")] = 20,
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警匹配规则列表。
-
-    按专业、关键字与启用状态过滤告警匹配规则，并以平面表格形式输出。
-
-    Args:
-        spec: 专业值列表，多个值同时参与匹配。
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        query: 可选关键字。
-        enabled: 可选启用状态过滤。
-
-    Examples:
-        >>> data-ops-cli alarm rule match list --spec MY_SPEC --page 0 --size 20
-    """
-    try:
-        group_nodes = service_list_alarm_rule_matches(page_num, page_size, query, enabled, spec)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if not group_nodes:
-        print("未查询到匹配告警规则")
-        return
-    print_list(
-        [
-            "告警匹配规则名称",
-            "规则类型(值)",
-            "启用状态",
-            "所属区域",
-            "专业类型(值)",
-            "创建人",
-            "更新时间",
-        ],
-        [
-            [
-                column.TITLE,
-                f"{column.N_RULE_TYPE}({column.RULE_TYPE})",
-                column.N_IS_ENABLED,
-                column.AREA,
-                f"{column.N_SPEC_TYPE}({column.SPEC_TYPE})",
-                column.CREATE_USER,
-                column.LAST_MODIFY_TIME,
-            ]
-            for column in group_nodes
-        ],
-    )
-
-
-@alarm_rule_typer.command("list", help="查询告警匹配规则")
-def list_alarm_rules(
-    spec: Annotated[list[str], typer.Option(help="专业值", default_factory=list)],
-    page_num: Annotated[int, typer.Option("-n", "--page-num", "--page", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", "--size", help="每页大小")] = 20,
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-) -> None:
-    """查询告警匹配规则列表。
-
-    这是前端 ``pages/alarm/rule`` 对应的 canonical 命令；旧的
-    ``alarm rule match list`` 仍保留作为兼容入口。
-    """
-    list_alarm_rules_match(spec, page_num, page_size, query, enabled)
-
-
-@alarm_rule_typer.command("detail", no_args_is_help=True)
-def get_alarm_rule_detail(
-    code: Annotated[str, typer.Argument(help="告警匹配规则编码")],
-    simplify: Annotated[bool, typer.Option("-s", "--simplify", help="简化详情输出")] = False,
-) -> None:
-    """按编码查询告警匹配规则基础详情。"""
-    _handle_alarm_detail(service_get_alarm_rule_detail, code, "告警匹配规则详情", simplify)
-
-
-@alarm_rule_typer.command("count", help="兼容查询告警规则类型数量")
-def count_alarm_rules_compat(
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-) -> None:
-    """兼容保留的原规则类型数量命令。
-
-    规则类型的 canonical 列表命令是 ``alarm rule type list``；匹配规则数量
-    仍使用 ``alarm rule match count``。
-    """
-    try:
-        total = service_count_alarm_rules(query, enabled)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-    print(total)
-
-
-@alarm_spec_typer.command("list", help="查询告警专业")
-def list_alarm_specs(
-    page_num: Annotated[int, typer.Option("-n", "--page-num", "--page", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", "--size", help="每页大小")] = 20,
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    active: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警专业列表。
-
-    按关键字与启用状态过滤告警专业（spec），输出标题、值、行业等基础字段。
-
-    Args:
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        query: 可选关键字。
-        active: 可选启用状态过滤。
-
-    Examples:
-        >>> data-ops-cli alarm spec list -q "网元"
-    """
-    group_nodes = service_list_alarm_specs(page_num, page_size, query, active)
-
-    print_list(
-        ["专业名称", "值", "行业", "启用状态", "创建人", "更新时间"],
-        [
-            [
-                column.TITLE,
-                column.CODE,
-                column.N_INDUSTRY,
-                column.N_IS_ENABLED,
-                column.CREATE_USER,
-                column.LAST_MODIFY_TIME,
-            ]
-            for column in group_nodes
-        ],
-    )
-
-
-@alarm_spec_typer.command("detail", no_args_is_help=True)
-def get_alarm_spec_detail(
-    code: Annotated[str, typer.Argument(help="告警专业编码")],
-    simplify: Annotated[bool, typer.Option("-s", "--simplify", help="简化详情输出")] = False,
-) -> None:
-    """按编码查询告警专业详情。"""
-    _handle_alarm_detail(service_get_alarm_spec_detail, code, "告警专业详情", simplify)
-
-
-@alarm_spec_typer.command("count", help="查询告警专业数量")
-def count_alarm_specs(
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警专业的总数。
-
-    Args:
-        query: 可选关键字。
-        enabled: 可选启用状态过滤。
-
-    Examples:
-        >>> data-ops-cli alarm spec count
-    """
-    total = service_count_alarm_specs(query, enabled)
-    print(total)
-
-
-@alarm_rule_type_typer.command("list", help="查询告警规则类型")
-def list_alarm_rule_types(
-    page_num: Annotated[int, typer.Option("-n", "--page-num", "--page", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", "--size", help="每页大小")] = 20,
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警规则类型列表。
-
-    按关键字与启用状态过滤告警规则，并以平面表格输出名称、值与启用状态。
-
-    Args:
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        query: 可选关键字。
-        enabled: 可选启用状态过滤。
-
-    Examples:
-        >>> data-ops-cli alarm rule type list -q "电压"
-    """
-    group_nodes = service_list_alarm_rules(page_num, page_size, query, enabled)
-
-    print_list(
-        ["规则名称", "值", "启用状态", "创建人", "更新时间"],
-        [
-            [
-                column.TITLE,
-                column.CODE,
-                column.N_IS_ENABLED,
-                column.CREATE_USER,
-                column.LAST_MODIFY_TIME,
-            ]
-            for column in group_nodes
-        ],
-    )
-
-
-@alarm_rule_type_typer.command("detail", no_args_is_help=True)
-def get_alarm_rule_type_detail(
-    code: Annotated[str, typer.Argument(help="告警规则类型编码")],
-    simplify: Annotated[bool, typer.Option("-s", "--simplify", help="简化详情输出")] = False,
-) -> None:
-    """按编码查询告警规则类型详情。"""
-    _handle_alarm_detail(service_get_alarm_rule_type_detail, code, "告警规则类型详情", simplify)
-
-
-@alarm_rule_type_typer.command("count", help="查询告警规则类型数量")
-def count_alarm_rule_types(
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警规则的总数。
-
-    Args:
-        query: 可选关键字。
-        enabled: 可选启用状态过滤。
-
-    Examples:
-        >>> data-ops-cli alarm rule type count
-    """
-    total = service_count_alarm_rules(query, enabled)
-    print(total)
-
-
-@alarm_action_typer.command("list", help="查询告警动作")
-def list_alarm_actions(
-    rule: Annotated[list[str], typer.Option(help="专业值", default_factory=list)],
-    page_num: Annotated[int, typer.Option("-n", "--page-num", "--page", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", "--size", help="每页大小")] = 20,
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警动作列表。
-
-    按所属规则、关键字与启用状态过滤告警动作，并以平面表格输出。
-
-    Args:
-        rule: 所属规则编码列表。
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        query: 可选关键字。
-        enabled: 可选启用状态过滤。
-
-    Examples:
-        >>> data-ops-cli alarm action list --rule MY_RULE
-    """
-    try:
-        group_nodes = service_list_alarm_action(page_num, page_size, query, enabled, rule)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if not group_nodes:
-        print("未查询到匹配告警动作")
-        return
-    print_list(
-        [
-            "动作名称",
-            "值",
-            "规则类型(值)",
-            "启用状态",
-            "创建人",
-            "更新时间",
-        ],
-        [
-            [
-                column.TITLE,
-                column.CODE,
-                f"{column.N_RULE_TYPE}({column.RULE_TYPE})",
-                column.N_IS_ENABLED,
-                column.CREATE_USER,
-                column.LAST_MODIFY_TIME,
-            ]
-            for column in group_nodes
-        ],
-    )
-
-
-@alarm_action_typer.command("detail", no_args_is_help=True)
-def get_alarm_action_detail(
-    code: Annotated[str, typer.Argument(help="告警动作编码")],
-    simplify: Annotated[bool, typer.Option("-s", "--simplify", help="简化详情输出")] = False,
-) -> None:
-    """按编码查询告警处置动作详情。"""
-    _handle_alarm_detail(service_get_alarm_action_detail, code, "告警处置动作详情", simplify)
-
-
-@alarm_action_typer.command("count", help="查询告警动作数量")
-def count_alarm_actions(
-    rule: Annotated[list[str], typer.Option(help="专业值", default_factory=list)],
-    query: Annotated[str | None, typer.Option("-q", "--query", help="搜索关键字")] = None,
-    enabled: Annotated[bool | None, typer.Option(help="启用状态")] = None,
-):
-    """查询告警动作的总数。
-
-    Args:
-        rule: 所属规则编码列表。
-        query: 可选关键字。
-        enabled: 可选启用状态过滤。
-
-    Examples:
-        >>> data-ops-cli alarm action count --rule MY_RULE
-    """
-    try:
-        total = service_count_alarm_action(query, enabled, rule)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-    print(total)
-
-
-@alarm_rule_typer.command("enums")
-def get_alarm_rule_enums() -> None:
-    """获取告警规则枚举配置。
-
-    后端返回 ``dict`` 时以两列 ``key/value`` 表渲染；其他结构以 JSON 形式输出。
-
-    Examples:
-        >>> data-ops-cli alarm rule enums
-    """
-    try:
-        data = service_get_alarm_rule_enums()
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if not data:
-        print("(空)")
-        return
-
-    if isinstance(data, dict):
-        table = Table("key", "value", show_header=False)
-        for k, v in data.items():
-            table.add_row(k, _safe_str(v))
-        console = Console(no_color=True)
-        console.print(table)
-    else:
-        print(to_json(data).decode("utf-8"))
-
-
-@alarm_rule_typer.command("find-meta-by-codes", no_args_is_help=True)
-def find_meta_by_codes(
-    codes: Annotated[list[str], typer.Argument(help="告警规则编码列表")],
-) -> None:
-    """根据告警规则编码批量查询关联元数据。
-
-    以 JSON 格式输出查询结果，便于人工检视或管道后续处理。
-
-    Args:
-        codes: 告警规则编码列表。
-
-    Examples:
-        >>> data-ops-cli alarm rule find-meta-by-codes code1 code2
-    """
-    try:
-        data = service_find_meta_by_codes(list(codes))
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    print(to_json(data).decode("utf-8"))
-
-
-@alarm_rule_typer.command("alarm-columns", no_args_is_help=True)
-def get_alarm_table_columns(
-    spec_type: Annotated[str, typer.Argument(help="告警规格类型")],
-) -> None:
-    """获取指定 specType 对应的告警表列定义。
-
-    Args:
-        spec_type: 告警规格类型编码。
-
-    Examples:
-        >>> data-ops-cli alarm rule alarm-columns MY_SPEC_TYPE
-    """
-    try:
-        columns = service_get_alarm_table_columns(spec_type)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    _print_column_list(columns)
-
-
-@alarm_rule_typer.command("rel-columns", no_args_is_help=True)
-def get_rel_table_columns(
-    code: Annotated[str, typer.Argument(help="告警规则编码")],
-) -> None:
-    """获取指定告警规则关联表的列定义。
-
-    Args:
-        code: 告警规则编码。
-
-    Examples:
-        >>> data-ops-cli alarm rule rel-columns rule_code_001
-    """
-    try:
-        columns = service_get_rel_table_columns(code)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    _print_column_list(columns)
-
-
-@alarm_rule_typer.command("data", no_args_is_help=True)
-def find_alarm_table_data(
-    code: Annotated[str, typer.Option(help="告警规则编码")],
-    query: Annotated[
-        str | None,
-        typer.Option(help="查询条件 JSON 字符串"),
-    ] = None,
-) -> None:
-    """查询指定数据源中告警表的实际数据（由告警规则写入的记录，非实时告警）。
-
-    ``--query`` 接收 JSON 字符串并解析为 dict 后透传给 SDK。
-
-    Args:
-        code: 告警规则编码。
-        query: 可选 JSON 字符串，表示查询条件。
-
-    Examples:
-        >>> data-ops-cli alarm rule data --code rule_code_001
-        >>> data-ops-cli alarm rule data --code rule_code_001 --query '{"date":"2026-07-16"}'
-    """
-    try:
-        query_dict = json.loads(query) if query else None
-    except json.JSONDecodeError as e:
-        typer.echo(f"错误: --query 不是合法 JSON: {e}")
-        raise typer.Exit(code=1) from None
-
-    try:
-        data = service_find_alarm_table_data(code, query_dict)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    print(to_json(data).decode("utf-8"))

data_ops_cli-0.5.1/src/dataops_cli/cli/hazard.py

@@ -1,406 +0,0 @@
-"""隐患管理命令组.
-
-- 服务层函数 (service_*)：纯 Python 接口，返回原始数据
-- CLI 命令：基于服务层的薄包装，负责格式化输出
-
-后端接口（位于 data-ops-guard 服务）：
-
-- /hazard/task/trigger/{code}
-- /hazard/task/logs/{taskCode}
-- /hazard/task/log/records/{taskId}
-- /hazard/record/list
-- /hazard/record/his/list
-- /hazard/record/dispatch/callback
-- /hazard/record/his/clear
-"""
-
-from __future__ import annotations
-
-import json
-from datetime import datetime
-from typing import Annotated, Any
-
-import typer
-from dataops_sdk.exceptions import DataOpsError
-from dataops_sdk.schemas.query import PageParam, SqlQueryParam
-from dataops_sdk.services import (
-    service_clear_hazard_history_records,
-    service_dispatch_hazard_callback,
-    service_get_hazard_task_log_records,
-    service_get_hazard_task_logs,
-    service_list_hazard_history_records,
-    service_list_hazard_records,
-    service_trigger_hazard_task,
-)
-from pydantic_core import to_json
-from rich.console import Console
-from rich.table import Table
-
-from dataops_cli.cli.utils import print_list
-
-# ---------------------------------------------------------------------------
-# CLI 命令（薄包装，负责输出渲染）
-# ---------------------------------------------------------------------------
-
-hazard_typer = typer.Typer(name="hazard", help="隐患相关命令", no_args_is_help=True)
-hazard_task_typer = typer.Typer(name="task", help="隐患任务命令", no_args_is_help=True)
-hazard_record_typer = typer.Typer(name="record", help="隐患记录命令", no_args_is_help=True)
-hazard_typer.add_typer(hazard_task_typer)
-hazard_typer.add_typer(hazard_record_typer)
-
-console = Console(no_color=True)
-
-
-# ---------------------------------------------------------------------------
-# 公共工具
-# ---------------------------------------------------------------------------
-
-
-def _parse_query_json(query: str | None) -> SqlQueryParam | None:
-    """把 ``--query`` JSON 字符串解析为 SqlQueryParam。
-
-    Args:
-        query: JSON 字符串；为空时直接返回 ``None``。
-    """
-    if not query:
-        return None
-    try:
-        data = json.loads(query)
-    except json.JSONDecodeError as e:
-        typer.echo(f"错误: --query 不是合法 JSON: {e}")
-        raise typer.Exit(code=2) from None
-    if not isinstance(data, dict):
-        typer.echo("错误: --query 必须是 JSON 对象")
-        raise typer.Exit(code=2) from None
-    return SqlQueryParam.model_validate(data)
-
-
-def _make_page_param(page: int, size: int) -> PageParam:
-    return PageParam(start=page * size, limit=size)
-
-
-def _print_dict_list(items: list[dict], columns: list[str] | None = None) -> None:
-    """以 Rich 表格打印字典列表.
-
-    Args:
-        items: 记录列表.
-        columns: 指定展示的列；为空时使用首条记录的全部 keys.
-    """
-    if not items:
-        console.print("(空)")
-        return
-    headers = columns or list(items[0].keys())
-    table = Table(*headers, show_header=True, header_style="bold")
-    for item in items:
-        row: list[Any] = []
-        for h in headers:
-            v = item.get(h)
-            if v is None:
-                row.append("")
-            elif isinstance(v, (dict, list)):
-                row.append(to_json(v).decode("utf-8"))
-            else:
-                row.append(str(v))
-        table.add_row(*row)
-    console.print(table)
-
-
-# ---------------------------------------------------------------------------
-# 隐患任务子命令
-# ---------------------------------------------------------------------------
-
-
-@hazard_task_typer.command("trigger", no_args_is_help=True)
-def trigger_hazard_task(
-    code: Annotated[str, typer.Argument(help="隐患任务编码")],
-    trigger_time: Annotated[
-        str | None,
-        typer.Option(
-            "--trigger-time",
-            help="ISO 时间字符串（如 2026-07-23T10:00:00）；缺省为立即触发",
-        ),
-    ] = None,
-    sync: Annotated[
-        bool,
-        typer.Option("--sync", help="同步执行（默认通过 Job 模板异步执行）"),
-    ] = False,
-) -> None:
-    """触发指定编码的隐患任务。
-
-    Args:
-        code: 隐患任务编码。
-        trigger_time: 可选 ISO 时间字符串，缺省时立即触发。
-        sync: 是否同步执行；默认通过 Job 模板异步执行。
-
-    Examples:
-        >>> data-ops-cli hazard task trigger task_hazard_001
-        >>> data-ops-cli hazard task trigger task_hazard_001 --sync
-        >>> data-ops-cli hazard task trigger task_hazard_001 \
-        ...     --trigger-time 2026-07-23T10:00:00
-    """
-    parsed_time: datetime | None = None
-    if trigger_time:
-        try:
-            parsed_time = datetime.fromisoformat(trigger_time)
-        except ValueError as e:
-            typer.echo(f"错误: --trigger-time 不是合法 ISO 时间: {e}")
-            raise typer.Exit(code=2) from None
-
-    try:
-        ok = service_trigger_hazard_task(code, trigger_time=parsed_time, sync=sync)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if ok:
-        console.print(f"已触发: {code}")
-    else:
-        typer.echo(f"触发失败: {code}")
-        raise typer.Exit(code=1) from None
-
-
-@hazard_task_typer.command("logs", no_args_is_help=True)
-def get_hazard_task_logs(
-    task_code: Annotated[str, typer.Argument(help="隐患任务编码")],
-    page_num: Annotated[int, typer.Option("-n", "--page-num", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", help="每页大小")] = 20,
-    count: Annotated[bool, typer.Option("--count", help="只返回记录数")] = False,
-) -> None:
-    """获取隐患任务日志列表（按 ``START_TIME DESC`` 排序）。
-
-    Args:
-        task_code: 隐患任务编码。
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        count: 是否只返回记录数。
-
-    Examples:
-        >>> data-ops-cli hazard task logs task_hazard_001
-        >>> data-ops-cli hazard task logs task_hazard_001 --page-num 0 --page-size 50
-        >>> data-ops-cli hazard task logs task_hazard_001 --count
-    """
-    try:
-        page_param = _make_page_param(page_num, page_size)
-        result = service_get_hazard_task_logs(task_code, page_param=page_param, count=count)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if count:
-        console.print(f"记录数: {result}")
-        return
-    _print_dict_list(result)
-
-
-@hazard_task_typer.command("log-records", no_args_is_help=True)
-def get_hazard_task_log_records(
-    task_id: Annotated[str, typer.Argument(help="隐患任务实例 ID")],
-    page_num: Annotated[int, typer.Option("-n", "--page-num", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", help="每页大小")] = 20,
-    count: Annotated[bool, typer.Option("--count", help="只返回记录数")] = False,
-) -> None:
-    """获取隐患任务结果记录（按 ``CREATE_TIME DESC`` 排序）。
-
-    Args:
-        task_id: 隐患任务实例 ID。
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        count: 是否只返回记录数。
-
-    Examples:
-        >>> data-ops-cli hazard task log-records run_001
-    """
-    try:
-        page_param = _make_page_param(page_num, page_size)
-        result = service_get_hazard_task_log_records(task_id, page_param=page_param, count=count)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if count:
-        console.print(f"记录数: {result}")
-        return
-    _print_dict_list(result)
-
-
-# ---------------------------------------------------------------------------
-# 隐患记录子命令
-# ---------------------------------------------------------------------------
-
-
-@hazard_record_typer.command("list", no_args_is_help=True)
-def list_hazard_records(
-    page_num: Annotated[int, typer.Option("-n", "--page-num", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", help="每页大小")] = 20,
-    query: Annotated[
-        str | None,
-        typer.Option(
-            "--query",
-            "-q",
-            help='SqlQueryParam JSON，如 \'{"conditionList":[{"name":"STATUS","value":1,"alias":"T0"}]}\'',
-        ),
-    ] = None,
-    count: Annotated[bool, typer.Option("--count", help="只返回记录数")] = False,
-) -> None:
-    """列出活动隐患记录。
-
-    Args:
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        query: SqlQueryParam JSON。
-        count: 是否只返回记录数。
-
-    Examples:
-        >>> data-ops-cli hazard record list
-        >>> data-ops-cli hazard record list -q '{"conditionList":[{"name":"STATUS","value":1,"alias":"T0"}]}'
-        >>> data-ops-cli hazard record list --count
-    """
-    try:
-        query_param = _parse_query_json(query)
-        page_param = _make_page_param(page_num, page_size)
-        result = service_list_hazard_records(
-            page_param=page_param,
-            query_param=query_param,
-            count=count,
-        )
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if count:
-        console.print(f"记录数: {result}")
-        return
-    _print_dict_list(result)
-
-
-@hazard_record_typer.command("his-list", no_args_is_help=True)
-def list_hazard_history_records(
-    page_num: Annotated[int, typer.Option("-n", "--page-num", help="页码")] = 0,
-    page_size: Annotated[int, typer.Option("-s", "--page-size", help="每页大小")] = 20,
-    query: Annotated[
-        str | None,
-        typer.Option("--query", "-q", help="SqlQueryParam JSON"),
-    ] = None,
-    count: Annotated[bool, typer.Option("--count", help="只返回记录数")] = False,
-) -> None:
-    """列出归档隐患记录。
-
-    Args:
-        page: 页码（从 0 开始）。
-        size: 每页条数。
-        query: SqlQueryParam JSON。
-        count: 是否只返回记录数。
-
-    Examples:
-        >>> data-ops-cli hazard record his-list
-        >>> data-ops-cli hazard record his-list --count
-    """
-    try:
-        query_param = _parse_query_json(query)
-        page_param = _make_page_param(page_num, page_size)
-        result = service_list_hazard_history_records(
-            page_param=page_param,
-            query_param=query_param,
-            count=count,
-        )
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if count:
-        console.print(f"记录数: {result}")
-        return
-    _print_dict_list(result)
-
-
-@hazard_record_typer.command("dispatch-callback", no_args_is_help=True)
-def dispatch_callback(
-    cuid: Annotated[str, typer.Option("--cuid", help="隐患记录 ID")],
-    order_no: Annotated[str, typer.Option("--order-no", help="外部工单号")],
-    dispatch_status: Annotated[
-        int,
-        typer.Option("--status", help="派遣状态码（业务自行约定，如 1=成功/2=失败）"),
-    ],
-) -> None:
-    """外部工单系统回写隐患派遣结果。
-
-    Args:
-        cuid: 隐患记录 ID。
-        order_no: 外部工单号。
-        dispatch_status: 派遣状态码。
-
-    Examples:
-        >>> data-ops-cli hazard record dispatch-callback \
-        ...     --cuid rec-123 --order-no WT-2026-001 --status 1
-    """
-    try:
-        ok = service_dispatch_hazard_callback(cuid, order_no, dispatch_status)
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if ok:
-        console.print(f"回调成功: cuid={cuid} orderNo={order_no} status={dispatch_status}")
-    else:
-        typer.echo("回调失败: 活动隐患不存在")
-        raise typer.Exit(code=1) from None
-
-
-@hazard_record_typer.command("his-clear", no_args_is_help=True)
-def clear_hazard_history_records(
-    cuid: Annotated[str, typer.Option("--cuid", help="归档隐患记录 ID")],
-    clear_notify_status: Annotated[
-        int | None,
-        typer.Option("--notify-status", help="清除通知状态码"),
-    ] = None,
-) -> None:
-    """清理指定归档隐患记录。
-
-    Args:
-        cuid: 归档隐患记录 ID。
-        clear_notify_status: 可选清除通知状态码。
-
-    Examples:
-        >>> data-ops-cli hazard record his-clear --cuid rec-archived-001
-        >>> data-ops-cli hazard record his-clear --cuid rec-archived-001 --notify-status 1
-    """
-    try:
-        ok = service_clear_hazard_history_records(
-            cuid,
-            clear_notify_status=clear_notify_status,
-        )
-    except DataOpsError as e:
-        typer.echo(f"错误: {e.message}")
-        raise typer.Exit(code=1) from None
-
-    if ok:
-        console.print(f"已清除: {cuid}")
-    else:
-        typer.echo("清除失败: 归档隐患记录不存在")
-        raise typer.Exit(code=1) from None
-
-
-# 兼容旧版 CLI（已弃用，保留直至 1.0）
-__all__ = ["hazard_typer"]
-
-
-# 旧接口（已弃用）的 stub，避免破坏外部 import
-def _safe_str(value: Any) -> str:
-    if value is None:
-        return ""
-    if isinstance(value, (dict, list)):
-        return to_json(value).decode("utf-8")
-    return str(value)
-
-
-# 兼容旧版 ``print_list`` 风格的快速打印
-def _legacy_print_dict_list(items: list) -> None:
-    if not items:
-        print("(空)")
-        return
-    if isinstance(items[0], dict):
-        headers = list(items[0].keys())
-        rows = [[_safe_str(item.get(h)) for h in headers] for item in items]
-        print_list(headers, rows)
-    else:
-        print(to_json(items).decode("utf-8"))