Initial commit

unilabos/app/backend.py

@@ -0,0 +1,35 @@
+import threading
+
+from unilabos.utils import logger
+
+
+# 根据选择的 backend 启动相应的功能
+def start_backend(
+    backend: str,
+    devices_config: dict = {},
+    resources_config: dict = {},
+    graph=None,
+    controllers_config: dict = {},
+    bridges=[],
+    without_host: bool = False,
+    **kwargs
+):
+    if backend == "ros":
+        # 假设 ros_main, simple_main, automancer_main 是不同 backend 的启动函数
+        from unilabos.ros.main_slave_run import main, slave  # 如果选择 'ros' 作为 backend
+    elif backend == 'simple':
+        # 这里假设 simple_backend 和 automancer_backend 是你定义的其他两个后端
+        # from simple_backend import main as simple_main
+        pass
+    elif backend == 'automancer':
+        # from automancer_backend import main as automancer_main
+        pass
+    else:
+        raise ValueError(f"Unsupported backend: {backend}")
+    
+    backend_thread = threading.Thread(
+        target=main if not without_host else slave,
+        args=(devices_config, resources_config, graph, controllers_config, bridges)
+    )
+    backend_thread.start()
+    logger.info(f"Backend {backend} started.")

unilabos/app/controler.py

@@ -0,0 +1,34 @@
+
+import json
+import uuid
+from unilabos.app.model import JobAddReq, JobData
+from unilabos.ros.nodes.presets.host_node import HostNode
+
+
+def get_resources() -> tuple:
+    if HostNode.get_instance() is None:
+        return False, "Host node not initialized"
+
+    return True, HostNode.get_instance().resources_config
+
+def devices() -> tuple:
+    if HostNode.get_instance() is None:
+        return False, "Host node not initialized"
+    
+    return True, HostNode.get_instance().devices_config
+
+def job_info(id: str):
+    get_goal_status = HostNode.get_instance().get_goal_status(id)
+    return JobData(jobId=id, status=get_goal_status)
+
+def job_add(req: JobAddReq) -> JobData:
+    if req.job_id is None:
+        req.job_id = str(uuid.uuid4())
+    action_name = req.data["action"]
+    action_kwargs = req.data["action_kwargs"]
+    req.data['action'] = action_name
+    if action_name == "execute_command_from_outer":
+        action_kwargs = {"command": json.dumps(action_kwargs)}
+    print(f"job_add:{req.device_id} {action_name} {action_kwargs}")
+    HostNode.get_instance().send_goal(req.device_id, action_name=action_name, action_kwargs=action_kwargs, goal_uuid=req.job_id)
+    return JobData(jobId=req.job_id)

unilabos/app/main.py

@@ -0,0 +1,155 @@
+import argparse
+import os
+import signal
+import sys
+import json
+import yaml
+from copy import deepcopy
+
+# 首先添加项目根目录到路径
+current_dir = os.path.dirname(os.path.abspath(__file__))
+ilabos_dir = os.path.dirname(os.path.dirname(current_dir))
+if ilabos_dir not in sys.path:
+    sys.path.append(ilabos_dir)
+
+from unilabos.config.config import load_config, BasicConfig
+from unilabos.utils.banner_print import print_status, print_unilab_banner
+
+
+def parse_args():
+    """解析命令行参数"""
+    parser = argparse.ArgumentParser(description="Start Uni-Lab Edge server.")
+    parser.add_argument("-g", "--graph", help="Physical setup graph.")
+    parser.add_argument("-d", "--devices", help="Devices config file.")
+    parser.add_argument("-r", "--resources", help="Resources config file.")
+    parser.add_argument("-c", "--controllers", default=None, help="Controllers config file.")
+    parser.add_argument(
+        "--registry_path",
+        type=str,
+        default=None,
+        action="append",
+        help="Path to the registry",
+    )
+    parser.add_argument(
+        "--backend",
+        choices=["ros", "simple", "automancer"],
+        default="ros",
+        help="Choose the backend to run with: 'ros', 'simple', or 'automancer'.",
+    )
+    parser.add_argument(
+        "--app_bridges",
+        nargs="+",
+        default=["mqtt", "fastapi"],
+        help="Bridges to connect to. Now support 'mqtt' and 'fastapi'.",
+    )
+    parser.add_argument(
+        "--without_host",
+        action="store_true",
+        help="Run the backend as slave (without host).",
+    )
+    parser.add_argument(
+        "--slave_no_host",
+        action="store_true",
+        help="Slave模式下跳过等待host服务",
+    )
+    parser.add_argument(
+        "--config",
+        type=str,
+        default=None,
+        help="配置文件路径，支持.py格式的Python配置文件",
+    )
+
+    return parser.parse_args()
+
+
+def main():
+    """主函数"""
+    # 解析命令行参数
+    args = parse_args()
+    args_dict = vars(args)
+
+    # 加载配置文件 - 这里保持最先加载配置的逻辑
+    if args_dict.get("config"):
+        config_path = args_dict["config"]
+        if not os.path.exists(config_path):
+            print_status(f"配置文件 {config_path} 不存在", "error")
+        elif not config_path.endswith(".py"):
+            print_status(f"配置文件 {config_path} 不是Python文件，必须以.py结尾", "error")
+        else:
+            load_config(config_path)
+
+    # 设置BasicConfig参数
+    BasicConfig.is_host_mode = not args_dict.get("without_host", False)
+    BasicConfig.slave_no_host = args_dict.get("slave_no_host", False)
+
+    from unilabos.resources.graphio import (
+        read_node_link_json,
+        read_graphml,
+        dict_from_graph,
+        dict_to_nested_dict,
+        initialize_resources,
+    )
+    from unilabos.app.mq import mqtt_client
+    from unilabos.registry.registry import build_registry
+    from unilabos.app.backend import start_backend
+    from unilabos.web import http_client
+    from unilabos.web import start_server
+
+    # 显示启动横幅
+    print_unilab_banner(args_dict)
+
+    # 注册表
+    build_registry(args_dict["registry_path"])
+
+    if args_dict["graph"] is not None:
+        import unilabos.resources.graphio as graph_res
+        graph_res.physical_setup_graph = (
+            read_node_link_json(args_dict["graph"])
+            if args_dict["graph"].endswith(".json")
+            else read_graphml(args_dict["graph"])
+        )
+        devices_and_resources = dict_from_graph(graph_res.physical_setup_graph)
+        args_dict["resources_config"] = initialize_resources(list(deepcopy(devices_and_resources).values()))
+        args_dict["devices_config"] = dict_to_nested_dict(deepcopy(devices_and_resources), devices_only=False)
+        # args_dict["resources_config"] = dict_to_tree(devices_and_resources, devices_only=False)
+        args_dict["graph"] = graph_res.physical_setup_graph
+    else:
+        if args_dict["devices"] is None or args_dict["resources"] is None:
+            print_status("Either graph or devices and resources must be provided.", "error")
+            sys.exit(1)
+        args_dict["devices_config"] = json.load(open(args_dict["devices"], encoding="utf-8"))
+        args_dict["resources_config"] = initialize_resources(
+            list(json.load(open(args_dict["resources"], encoding="utf-8")).values())
+        )
+
+    print_status(f"{len(args_dict['resources_config'])} Resources loaded:", "info")
+    for i in args_dict["resources_config"]:
+        print_status(f"DeviceId: {i['id']}, Class: {i['class']}", "info")
+
+    if args_dict["controllers"] is not None:
+        args_dict["controllers_config"] = yaml.safe_load(open(args_dict["controllers"], encoding="utf-8"))
+    else:
+        args_dict["controllers_config"] = None
+
+    args_dict["bridges"] = []
+
+    if "mqtt" in args_dict["app_bridges"]:
+        args_dict["bridges"].append(mqtt_client)
+    if "fastapi" in args_dict["app_bridges"]:
+        args_dict["bridges"].append(http_client)
+    if "mqtt" in args_dict["app_bridges"]:
+
+        def _exit(signum, frame):
+            mqtt_client.stop()
+            sys.exit(0)
+
+        signal.signal(signal.SIGINT, _exit)
+        signal.signal(signal.SIGTERM, _exit)
+        mqtt_client.start()
+
+    start_backend(**args_dict)
+    start_server()
+
+
+if __name__ == "__main__":
+    main()

unilabos/app/model.py

@@ -0,0 +1,137 @@
+from pydantic import BaseModel, Field
+
+
+class RespCode:
+    Success = 0
+
+    ErrorHostNotInit = 2001  # Host node not initialized
+    ErrorInvalidReq = 2002  # Invalid request data
+
+
+class DeviceAction(BaseModel):
+    x: str
+    y: str
+    action: str
+
+
+class Device(BaseModel):
+    id: str
+    name: str
+    action: DeviceAction
+
+
+class DeviceList(BaseModel):
+    items: list[Device] = []
+    page: int
+    pageSize: int
+
+
+class DevicesResponse(BaseModel):
+    code: int
+    data: DeviceList
+
+
+class DeviceInfoResponse(BaseModel):
+    code: int
+    data: Device
+
+
+class PageResp(BaseModel):
+    item: list = []
+    page: int = 1
+    pageSize: int = 10
+
+
+class Resp(BaseModel):
+    code: int = RespCode.Success
+    data: dict = {}
+    message: str = "success"
+
+
+class JobAddReq(BaseModel):
+    device_id: str = Field(examples=["Gripper"], description="device id")
+    data: dict = Field(examples=[{"position": 30, "torque": 5, "action": "push_to"}])
+    job_id: str = Field(examples=["sfsfsfeq"], description="goal uuid")
+    node_id: str = Field(examples=["sfsfsfeq"], description="node uuid")
+
+
+class JobStepFinishReq(BaseModel):
+    token: str = Field(examples=["030944"], description="token")
+    request_time: str = Field(
+        examples=["2024-12-12 12:12:12.xxx"], description="requestTime"
+    )
+    data: dict = Field(
+        examples=[
+            {
+                "orderCode": "任务号。字符串",
+                "orderName": "任务名称。字符串",
+                "stepName": "步骤名称。字符串",
+                "stepId": "步骤Id。GUID",
+                "sampleId": "通量Id。GUID",
+                "startTime": "开始时间。时间格式",
+                "endTime": "完成时间。时间格式",
+            }
+        ]
+    )
+
+
+class JobPreintakeFinishReq(BaseModel):
+    token: str = Field(examples=["030944"], description="token")
+    request_time: str = Field(
+        examples=["2024-12-12 12:12:12.xxx"], description="requestTime"
+    )
+    data: dict = Field(
+        examples=[
+            {
+                "orderCode": "任务号。字符串",
+                "orderName": "任务名称。字符串",
+                "sampleId": "通量Id。GUID",
+                "startTime": "开始时间。时间格式",
+                "endTime": "完成时间。时间格式",
+                "Status": "通量状态,0待生产、2进样、10开始、完成20、异常停止-2、人工停止或取消-3",
+            }
+        ]
+    )
+
+
+class JobFinishReq(BaseModel):
+    token: str = Field(examples=["030944"], description="token")
+    request_time: str = Field(
+        examples=["2024-12-12 12:12:12.xxx"], description="requestTime"
+    )
+    data: dict = Field(
+        examples=[
+            {
+                "orderCode": "任务号。字符串",
+                "orderName": "任务名称。字符串",
+                "startTime": "开始时间。时间格式",
+                "endTime": "完成时间。时间格式",
+                "status": "通量状态,完成30、异常停止-11、人工停止或取消-12",
+                "usedMaterials": [
+                    {
+                        "materialId": "物料Id。GUID",
+                        "locationId": "库位Id。GUID",
+                        "typeMode": "物料类型。 样品1、试剂2、耗材0",
+                        "usedQuantity": "使用的数量。 数字",
+                    }
+                ],
+            }
+        ]
+    )
+
+
+class JobData(BaseModel):
+    jobId: str = Field(examples=["sfsfsfeq"], description="goal uuid")
+    status: int = Field(
+        examples=[0, 1],
+        default=0,
+        description="0:UNKNOWN, 1:ACCEPTED, 2:EXECUTING, 3:CANCELING, 4:SUCCEEDED, 5:CANCELED, 6:ABORTED",
+    )
+
+
+class JobStatusResp(Resp):
+    data: JobData
+
+
+class JobAddResp(Resp):
+    data: JobData

unilabos/app/mq.py

@@ -0,0 +1,177 @@
+import json
+import time
+import uuid
+
+import paho.mqtt.client as mqtt
+import ssl, base64, hmac
+from hashlib import sha1
+import tempfile
+import os
+
+from unilabos.config.config import MQConfig
+from unilabos.app.controler import devices, job_add
+from unilabos.app.model import JobAddReq, JobAddResp
+from unilabos.utils import logger
+from unilabos.utils.type_check import TypeEncoder
+
+
+class MQTTClient:
+    mqtt_disable = True
+
+    def __init__(self):
+        self.mqtt_disable = not MQConfig.lab_id
+        self.client_id = f"{MQConfig.group_id}@@@{MQConfig.lab_id}{uuid.uuid4()}"
+        self.client = mqtt.Client(mqtt.CallbackAPIVersion.VERSION2, client_id=self.client_id, protocol=mqtt.MQTTv5)
+        self._setup_callbacks()
+
+    def _setup_callbacks(self):
+        self.client.on_log = self._on_log
+        self.client.on_connect = self._on_connect
+        self.client.on_message = self._on_message
+        self.client.on_disconnect = self._on_disconnect
+
+    def _on_log(self, client, userdata, level, buf):
+        logger.info(f"[MQTT] log: {buf}")
+
+    def _on_connect(self, client, userdata, flags, rc, properties=None):
+        logger.info("[MQTT] Connected with result code " + str(rc))
+        client.subscribe(f"labs/{MQConfig.lab_id}/job/start/", 0)
+        isok, data = devices()
+        if not isok:
+            logger.error("[MQTT] on_connect ErrorHostNotInit")
+            return
+
+    def _on_message(self, client, userdata, msg):
+        logger.info("[MQTT] on_message<<<< " + msg.topic + " " + str(msg.payload))
+        try:
+            payload_str = msg.payload.decode("utf-8")
+            payload_json = json.loads(payload_str)
+            logger.debug(f"Topic: {msg.topic}")
+            logger.debug("Payload:", json.dumps(payload_json, indent=2, ensure_ascii=False))
+            if msg.topic == f"labs/{MQConfig.lab_id}/job/start/":
+                logger.debug("job_add", type(payload_json), payload_json)
+                job_req = JobAddReq.model_validate(payload_json)
+                data = job_add(job_req)
+                return JobAddResp(data=data)
+
+        except json.JSONDecodeError as e:
+            logger.error(f"[MQTT] JSON 解析错误: {e}")
+            logger.error(f"[MQTT] Raw message: {msg.payload}")
+        except Exception as e:
+            logger.error(f"[MQTT] 处理消息时出错: {e}")
+
+    def _on_disconnect(self, client, userdata, rc, reasonCode=None, properties=None):
+        if rc != 0:
+            logger.error(f"[MQTT] Unexpected disconnection {rc}")
+
+    def _setup_ssl_context(self):
+        temp_files = []
+        try:
+            with tempfile.NamedTemporaryFile(mode="w", delete=False) as ca_temp:
+                ca_temp.write(MQConfig.ca_content)
+                temp_files.append(ca_temp.name)
+
+            with tempfile.NamedTemporaryFile(mode="w", delete=False) as cert_temp:
+                cert_temp.write(MQConfig.cert_content)
+                temp_files.append(cert_temp.name)
+
+            with tempfile.NamedTemporaryFile(mode="w", delete=False) as key_temp:
+                key_temp.write(MQConfig.key_content)
+                temp_files.append(key_temp.name)
+
+            context = ssl.create_default_context(ssl.Purpose.SERVER_AUTH)
+            context.load_verify_locations(cafile=temp_files[0])
+            context.load_cert_chain(certfile=temp_files[1], keyfile=temp_files[2])
+            self.client.tls_set_context(context)
+        finally:
+            for temp_file in temp_files:
+                try:
+                    os.unlink(temp_file)
+                except:
+                    pass
+
+    def start(self):
+        if self.mqtt_disable:
+            logger.warning("MQTT is disabled, skipping connection.")
+            return
+        userName = f"Signature|{MQConfig.access_key}|{MQConfig.instance_id}"
+        password = base64.b64encode(
+            hmac.new(MQConfig.secret_key.encode(), self.client_id.encode(), sha1).digest()
+        ).decode()
+
+        self.client.username_pw_set(userName, password)
+        self._setup_ssl_context()
+
+        # 创建连接线程
+        def connect_thread_func():
+            try:
+                self.client.connect(MQConfig.broker_url, MQConfig.port, 60)
+                self.client.loop_start()
+
+                # 添加连接超时检测
+                max_attempts = 5
+                attempt = 0
+                while not self.client.is_connected() and attempt < max_attempts:
+                    logger.info(
+                        f"[MQTT] 正在连接到 {MQConfig.broker_url}:{MQConfig.port}，尝试 {attempt+1}/{max_attempts}"
+                    )
+                    time.sleep(3)
+                    attempt += 1
+
+                if self.client.is_connected():
+                    logger.info(f"[MQTT] 已成功连接到 {MQConfig.broker_url}:{MQConfig.port}")
+                else:
+                    logger.error(f"[MQTT] 连接超时，可能是账号密码错误或网络问题")
+                    self.client.loop_stop()
+            except Exception as e:
+                logger.error(f"[MQTT] 连接失败: {str(e)}")
+
+        connect_thread_func()
+        # connect_thread = threading.Thread(target=connect_thread_func)
+        # connect_thread.daemon = True
+        # connect_thread.start()
+
+    def stop(self):
+        if self.mqtt_disable:
+            return
+        self.client.disconnect()
+        self.client.loop_stop()
+
+    def publish_device_status(self, device_status: dict, device_id, property_name):
+        # status = device_status.get(device_id, {})
+        if self.mqtt_disable:
+            return
+        status = {"data": device_status.get(device_id, {}), "device_id": device_id}
+        address = f"labs/{MQConfig.lab_id}/devices"
+        self.client.publish(address, json.dumps(status), qos=2)
+        logger.critical(f"Device status published: address: {address}, {status}")
+
+    def publish_job_status(self, feedback_data: dict, job_id: str, status: str):
+        if self.mqtt_disable:
+            return
+        jobdata = {"job_id": job_id, "data": feedback_data, "status": status}
+        self.client.publish(f"labs/{MQConfig.lab_id}/job/list/", json.dumps(jobdata), qos=2)
+    
+    def publish_registry(self, device_id: str, device_info: dict):
+        if self.mqtt_disable:
+            return
+        address = f"labs/{MQConfig.lab_id}/registry/"
+        registry_data = json.dumps({device_id: device_info}, ensure_ascii = False, cls = TypeEncoder)
+        self.client.publish(address, registry_data, qos=2)
+        logger.debug(f"Registry data published: address: {address}, {registry_data}")
+
+    def publish_actions(self, action_id: str, action_info: dict):
+        if self.mqtt_disable:
+            return
+        address = f"labs/{MQConfig.lab_id}/actions/"
+        action_type_name = action_info["title"]
+        action_info["title"] = action_id
+        action_data = json.dumps({action_type_name: action_info}, ensure_ascii=False)
+        self.client.publish(address, action_data, qos=2)
+        logger.debug(f"Action data published: address: {address}, {action_data}")
+
+
+mqtt_client = MQTTClient()
+
+if __name__ == "__main__":
+    mqtt_client.start()

unilabos/app/oss_upload.py

@@ -0,0 +1,231 @@
+import argparse
+import os
+import time
+from typing import Dict, Optional, Tuple
+
+import requests
+
+from unilabos.config.config import OSSUploadConfig
+
+
+def _init_upload(file_path: str, oss_path: str, filename: Optional[str] = None,
+                process_key: str = "file-upload", device_id: str = "default",
+                expires_hours: int = 1) -> Tuple[bool, Dict]:
+    """
+    初始化上传过程
+
+    Args:
+        file_path: 本地文件路径
+        oss_path: OSS目标路径
+        filename: 文件名，如果为None则使用file_path的文件名
+        process_key: 处理键
+        device_id: 设备ID
+        expires_hours: 链接过期小时数
+
+    Returns:
+        (成功标志, 响应数据)
+    """
+    if filename is None:
+        filename = os.path.basename(file_path)
+
+    # 构造初始化请求
+    url = f"{OSSUploadConfig.api_host}{OSSUploadConfig.init_endpoint}"
+    headers = {
+        "Authorization": OSSUploadConfig.authorization,
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "device_id": device_id,
+        "process_key": process_key,
+        "filename": filename,
+        "path": oss_path,
+        "expires_hours": expires_hours
+    }
+
+    try:
+        response = requests.post(url, headers=headers, json=payload)
+        if response.status_code == 201:
+            result = response.json()
+            if result.get("code") == "10000":
+                return True, result.get("data", {})
+
+        print(f"初始化上传失败: {response.status_code}, {response.text}")
+        return False, {}
+    except Exception as e:
+        print(f"初始化上传异常: {str(e)}")
+        return False, {}
+
+
+def _put_upload(file_path: str, upload_url: str) -> bool:
+    """
+    执行PUT上传
+
+    Args:
+        file_path: 本地文件路径
+        upload_url: 上传URL
+
+    Returns:
+        是否成功
+    """
+    try:
+        with open(file_path, "rb") as f:
+            response = requests.put(upload_url, data=f)
+            if response.status_code == 200:
+                return True
+
+        print(f"PUT上传失败: {response.status_code}, {response.text}")
+        return False
+    except Exception as e:
+        print(f"PUT上传异常: {str(e)}")
+        return False
+
+
+def _complete_upload(uuid: str) -> bool:
+    """
+    完成上传过程
+
+    Args:
+        uuid: 上传的UUID
+
+    Returns:
+        是否成功
+    """
+    url = f"{OSSUploadConfig.api_host}{OSSUploadConfig.complete_endpoint}"
+    headers = {
+        "Authorization": OSSUploadConfig.authorization,
+        "Content-Type": "application/json"
+    }
+
+    payload = {
+        "uuid": uuid
+    }
+
+    try:
+        response = requests.post(url, headers=headers, json=payload)
+        if response.status_code == 200:
+            result = response.json()
+            if result.get("code") == "10000":
+                return True
+
+        print(f"完成上传失败: {response.status_code}, {response.text}")
+        return False
+    except Exception as e:
+        print(f"完成上传异常: {str(e)}")
+        return False
+
+
+def oss_upload(file_path: str, oss_path: str, filename: Optional[str] = None,
+              process_key: str = "file-upload", device_id: str = "default") -> bool:
+    """
+    文件上传主函数，包含重试机制
+
+    Args:
+        file_path: 本地文件路径
+        oss_path: OSS目标路径
+        filename: 文件名，如果为None则使用file_path的文件名
+        process_key: 处理键
+        device_id: 设备ID
+
+    Returns:
+        是否成功上传
+    """
+    max_retries = OSSUploadConfig.max_retries
+    retry_count = 0
+
+    while retry_count < max_retries:
+        try:
+            # 步骤1：初始化上传
+            init_success, init_data = _init_upload(
+                file_path=file_path,
+                oss_path=oss_path,
+                filename=filename,
+                process_key=process_key,
+                device_id=device_id
+            )
+
+            if not init_success:
+                print(f"初始化上传失败，重试 {retry_count + 1}/{max_retries}")
+                retry_count += 1
+                time.sleep(1)  # 等待1秒后重试
+                continue
+
+            # 获取UUID和上传URL
+            uuid = init_data.get("uuid")
+            upload_url = init_data.get("upload_url")
+
+            if not uuid or not upload_url:
+                print(f"初始化上传返回数据不完整，重试 {retry_count + 1}/{max_retries}")
+                retry_count += 1
+                time.sleep(1)
+                continue
+
+            # 步骤2：PUT上传文件
+            put_success = _put_upload(file_path, upload_url)
+            if not put_success:
+                print(f"PUT上传失败，重试 {retry_count + 1}/{max_retries}")
+                retry_count += 1
+                time.sleep(1)
+                continue
+
+            # 步骤3：完成上传
+            complete_success = _complete_upload(uuid)
+            if not complete_success:
+                print(f"完成上传失败，重试 {retry_count + 1}/{max_retries}")
+                retry_count += 1
+                time.sleep(1)
+                continue
+
+            # 所有步骤都成功
+            print(f"文件 {file_path} 上传成功")
+            return True
+
+        except Exception as e:
+            print(f"上传过程异常: {str(e)}，重试 {retry_count + 1}/{max_retries}")
+            retry_count += 1
+            time.sleep(1)
+
+    print(f"文件 {file_path} 上传失败，已达到最大重试次数 {max_retries}")
+    return False
+
+
+if __name__ == "__main__":
+    # python -m unilabos.app.oss_upload -f /path/to/your/file.txt
+    # 命令行参数解析
+    parser = argparse.ArgumentParser(description='文件上传测试工具')
+    parser.add_argument('--file', '-f', type=str, required=True, help='要上传的本地文件路径')
+    parser.add_argument('--path', '-p', type=str, default='/HPLC1/Any', help='OSS目标路径')
+    parser.add_argument('--device', '-d', type=str, default='test-device', help='设备ID')
+    parser.add_argument('--process', '-k', type=str, default='HPLC-txt-result', help='处理键')
+
+    args = parser.parse_args()
+
+    # 检查文件是否存在
+    if not os.path.exists(args.file):
+        print(f"错误：文件 {args.file} 不存在")
+        exit(1)
+
+    print("=" * 50)
+    print(f"开始上传文件: {args.file}")
+    print(f"目标路径: {args.path}")
+    print(f"设备ID: {args.device}")
+    print(f"处理键: {args.process}")
+    print("=" * 50)
+
+    # 执行上传
+    success = oss_upload(
+        file_path=args.file,
+        oss_path=args.path,
+        filename=None,  # 使用默认文件名
+        process_key=args.process,
+        device_id=args.device
+    )
+
+    # 输出结果
+    if success:
+        print("\n√ 文件上传成功！")
+        exit(0)
+    else:
+        print("\n× 文件上传失败！")
+        exit(1)
+