file

文件相关 CLI 命令。

cmd_file_close(fmt, file_id)

在 Dimine 中关闭文件（需 Dimine 运行）。

Source code in dimine_python_sdk\cli\commands\file.py

def cmd_file_close(fmt: str, file_id: str) -> None:
    """在 Dimine 中关闭文件（需 Dimine 运行）。"""
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    async def _run():
        client = await get_client()
        await client.close_file(file_id)
        return {
            "success": True,
            "file_id": file_id,
            "message": f"已关闭文件: {file_id}",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "关闭文件失败")

cmd_file_create(fmt, path)

在 Dimine 中创建新的空文件（需 Dimine 运行）。

Source code in dimine_python_sdk\cli\commands\file.py

def cmd_file_create(fmt: str, path: str) -> None:
    """在 Dimine 中创建新的空文件（需 Dimine 运行）。"""
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    file_path = resolve_path(path)

    async def _run():
        client = await get_client()
        await client.create_file(file_path)
        return {
            "success": True,
            "path": file_path,
            "message": f"已创建文件: {file_path}",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "创建文件失败")

cmd_file_open(fmt, path)

在 Dimine 中打开文件（需 Dimine 运行）。同名文件已打开则先关闭再重开；打开 .dmo 前会把已打开的其它 .dmo 一并关闭。

Source code in dimine_python_sdk\cli\commands\file.py

def cmd_file_open(fmt: str, path: str) -> None:
    """在 Dimine 中打开文件（需 Dimine 运行）。同名文件已打开则先关闭再重开；打开 .dmo 前会把已打开的其它 .dmo 一并关闭。"""
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    file_path = resolve_path(path)

    async def _run():
        client = await get_client()

        # 先确认待打开的新文件存在，再考虑关闭已打开文件，避免误关旧文件后才发现打不开
        if not os.path.isfile(file_path):
            raise_or_exit(f"文件不存在: {file_path}", fmt)

        # Dimine 同一时刻只能打开一个 .dmo（炮孔数据库）文件：打开 .dmo 前若已有
        # .dmo 打开须先关闭，否则 open_file 会提示 "file already opened"。
        is_dmo = str(file_path).lower().endswith(".dmo")
        # 检查是否有同名文件已打开，如果有则先关闭
        target_name = path
        opened_files = await client.get_files()
        for f in opened_files:
            if is_dmo:
                # DMO：关闭当前已打开的所有 .dmo 文件
                if (f.name or "").lower().endswith(".dmo"):
                    logger.info("file-open: 打开新 .dmo 前关闭已打开文件（id=%s name=%s）", f.id, f.name)
                    await client.close_file(f.id)
            else:
                # 非 DMO：仅当同名文件已打开时先关闭再重新打开
                if f.name == target_name:
                    logger.info("file-open: 同名文件已打开，先关闭再重开（id=%s name=%s）", f.id, f.name)
                    await client.close_file(f.id)
                    break

        # 打开文件
        await client.open_file(file_path)
        return {
            "success": True,
            "path": file_path,
            "message": f"已打开文件: {file_path}",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "打开文件失败")

cmd_file_save(fmt, output_path, file_id)

将已打开的文件导出保存到本地指定路径（需 Dimine 运行）。

Source code in dimine_python_sdk\cli\commands\file.py

def cmd_file_save(fmt: str, output_path: str, file_id: str | None) -> None:
    """将已打开的文件导出保存到本地指定路径（需 Dimine 运行）。"""
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    save_path = resolve_path(output_path)

    async def _run():
        nonlocal file_id
        client = await get_client()
        if not file_id:
            files = await client.get_files()
            if not files:
                raise_or_exit("没有打开的文件。请先在 Dimine 中打开文件，或提供 --file-id 参数。", fmt)
            if len(files) == 1:
                file_id = files[0].id
            else:
                file_list = "\n".join([f"  - id: {f.id}, name: {f.name}" for f in files])
                raise_or_exit(
                    f"当前打开了 {len(files)} 个文件，请指定 --file-id：\n{file_list}",
                    fmt,
                )
        await client.export_file(file_id=file_id, file_path=save_path)
        return {
            "success": True,
            "file_id": file_id,
            "saved_to": save_path,
            "message": f"文件已保存: {save_path}",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except SystemExit:
        raise
    except Exception as e:
        handle_sdk_error(e, fmt, "保存文件失败")

cmd_file_tree(fmt)

获取当前场景中已打开的所有文件及每个文件的图层信息（需 Dimine 运行）。

Source code in dimine_python_sdk\cli\commands\file.py

def cmd_file_tree(fmt: str) -> None:
    """获取当前场景中已打开的所有文件及每个文件的图层信息（需 Dimine 运行）。"""
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    async def _run():
        client = await get_client()
        files = await client.get_files()
        result = []
        for f in files:
            file_info = {"id": f.id, "name": f.name, "layers": []}
            try:
                layers = await client.get_layers(f.id)
                for layer in layers:
                    file_info["layers"].append({"id": layer.id, "name": layer.name})
            except Exception:
                pass
            result.append(file_info)
        return {"file_count": len(result), "files": result, "info":"注：非dmf文件layers为空是正常的，他有三维对象显示在Dimine中。"}

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "获取文件树失败")

cmd_file_visibility(fmt, file_id, action)

设置文件显示/隐藏状态（需 Dimine 运行）。

Source code in dimine_python_sdk\cli\commands\file.py

def cmd_file_visibility(fmt: str, file_id: str, action: str) -> None:
    """设置文件显示/隐藏状态（需 Dimine 运行）。"""
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    from dimine_python_sdk.models.conn import VisibilityAction

    valid_actions = {
        "show": VisibilityAction.SHOW,
        "hide": VisibilityAction.HIDE,
        "exclusive_show": VisibilityAction.EXCLUSIVE_SHOW,
    }

    async def _run():
        client = await get_client()
        await client.set_file_visibility(
            file_id=file_id,
            action=valid_actions[action],
        )
        action_cn = {"show": "显示", "hide": "隐藏", "exclusive_show": "排他显示"}
        return {
            "success": True,
            "message": f"已成功{action_cn.get(action, action)}文件 {file_id}",
        }

    try:
        result = run_cli_async(_run())
        output_result(result, fmt)
    except Exception as e:
        handle_sdk_error(e, fmt, "设置文件可见性失败")

register_commands(subparsers, format_parent)

向 subparsers 注册文件相关子命令。

Source code in dimine_python_sdk\cli\commands\file.py

def register_commands(subparsers, format_parent) -> None:
    """向 subparsers 注册文件相关子命令。"""
    subparsers.add_parser("file-tree", parents=[format_parent], help="获取打开文件及图层树")

    p = subparsers.add_parser("file-save", parents=[format_parent], help="导出文件到本地")
    p.add_argument("--output", required=True, dest="output_path", help="保存/导出目标路径，需包含文件扩展名")
    p.add_argument("--file-id", default=None, help="文件ID，多个文件打开时必填")

    p = subparsers.add_parser("file-open", parents=[format_parent], help="打开文件到 Dimine 场景")
    p.add_argument("--path", "--file", required=True, help="要打开的 .dmf/.dwg/.dxf 等文件路径")

    p = subparsers.add_parser("file-close", parents=[format_parent], help="关闭 Dimine 中的文件")
    p.add_argument("--file-id", required=True, help="要关闭的文件ID")

    p = subparsers.add_parser("file-create", parents=[format_parent], help="在 Dimine 中创建新的空文件")
    p.add_argument("--path", "--file", required=True, help="新文件的路径")

    p = subparsers.add_parser("file-visibility", parents=[format_parent], help="设置文件显示/隐藏状态")
    p.add_argument("--file-id", required=True, help="文件ID")
    p.add_argument("--action", choices=["show", "hide", "exclusive_show"], default="show", help="操作类型（默认: show）")