Skip to content

file

文件相关 CLI 命令。

cmd_file_close(fmt, file_id)

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

Source code in dimine_python_sdk\cli\commands\file.py 
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
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 
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
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 运行）。如果文件已在 Dimine 中打开，先关闭再重新打开。

Source code in dimine_python_sdk\cli\commands\file.py 
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
def cmd_file_open(fmt: str, path: str) -> None:
    """在 Dimine 中打开文件（需 Dimine 运行）。如果文件已在 Dimine 中打开，先关闭再重新打开。"""
    err = require_remote_sdk()
    if err:
        output_error(err, fmt)

    file_path = resolve_path(path)

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

        # 检查是否有同名文件已打开，如果有则先关闭
        target_name = path
        opened_files = await client.get_files()
        for f in opened_files:
            if f.name == target_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 
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
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 
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
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}

    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 
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
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 
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
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）")