repo_id
stringclasses 1
value | file_path
stringlengths 31
102
| content
stringlengths 16
34k
| __index_level_0__
int64 0
0
|
|---|---|---|---|
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\README.md | # WCS Adaptor
## 如何翻译文本
## 如何配置 VS Code
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\config\default.yaml | system:
project_type: "dpt"
db:
sqlalchemy_track_modifications: false
sqlalchemy_database_uri: "sqlite:///max_hmi.db?check_same_thread=false"
listener:
# 急停信号监听
estop:
enable: false
# 大于等于 1, 下同
interval: 1
# 三色灯监听
light:
enable: true
interval: 1
# VP 流图状态监听
vp_status:
enable: true
interval: 1
# WCS 状态监听(心跳监听)
wcs_status:
enable: false
interval: 1
# 机器人连接状态监听
robot_connection_status:
enable: false
interval: 5
plc:
device_id: "2"
address:
grating: 130 # 光栅地址
buzzer: 124 # 蜂鸣器地址
# WARN: 三色灯顺序必须是：黄、绿、红，且必须连续的
yellow: 121 # 绿灯地址
green: 122 # 黄灯地址
red: 123 # 红灯地址
estop: 5 # 急停信号地址
task_manager:
enable: true
size: -1
order_manager:
enable: true
size: -1 # TODO: 根据项目类型设定
socket:
host: "0.0.0.0"
port: 7001
hmi: # nginx 对外的端口
host: "0.0.0.0"
port: 7002
server: # 后端程序内部的端口
host: "0.0.0.0"
port: 7003
wcs:
host: "127.0.0.1"
port: 12000
dev_mode:
mock_wcs: false
notify:
enable: true
wechat: ""
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\config\mockoon.json | {
"uuid": "a1274e33-c740-4154-9183-4c17d3b96eea",
"lastMigration": 28,
"name": "FastAPI",
"endpointPrefix": "",
"latency": 0,
"port": 12000,
"hostname": "",
"folders": [],
"routes": [
{
"uuid": "07648d7b-0402-4cff-bb5f-71f9dbc5d10e",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "request/wcs/single_class_depal_task/report_task_status",
"responses": [
{
"uuid": "a8da2105-5fbe-4144-8aaf-3001e4a703a4",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "5f426281-d0b4-47b1-9d1f-3f15a9919323",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "request/wcs/single_class_depal_task/report_task_status",
"responses": [
{
"uuid": "41db9b8c-1eea-4aa6-9d7f-f79cd4b91bd8",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "e78d7ce7-94a4-4e94-86c2-d2adf7447085",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/batch_result",
"responses": [
{
"uuid": "77d10ff7-684d-411b-a1bd-79ecd07a77d6",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "a4e79864-050a-49dd-8a79-cf2ede55881d",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/batch_result",
"responses": [
{
"uuid": "160d5455-5214-4620-aba2-a3ec574e6d16",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "58bd1039-b751-4a58-96cd-9660e3428a4f",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "request/wcs/single_class_pal_task/report_action_status",
"responses": [
{
"uuid": "9536bd58-9539-4b49-862b-88e1b12473f9",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "62ff6cb8-b392-41ff-9cc4-f9150a81d84c",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "request/wcs/single_class_pal_task/report_action_status",
"responses": [
{
"uuid": "9290fad6-f109-43f9-a8a7-44e6569c562e",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "67d7e04c-3efc-4a69-9cda-681a834a7cf6",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/exception",
"responses": [
{
"uuid": "81ba57cf-6f71-432e-ab00-58be9ad78413",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "f3bfe8a7-e759-4d5e-a92b-8c019fb3bf20",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/exception",
"responses": [
{
"uuid": "b6d0e5e4-74e9-4546-8431-9934478949f8",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "1b5a19d7-4b39-432f-acd4-a3eb1524a38d",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/health_check",
"responses": [
{
"uuid": "4d1ffaac-a867-4d21-a063-acaffec2d2fe",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "0a62a329-49d7-40a1-b255-352ddb625386",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/health_check",
"responses": [
{
"uuid": "1513c8bb-b2b3-43b1-91d5-092f9028e4e4",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "9fee32c4-89ec-478c-9bfe-dd8aeaef9a39",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/planning_result",
"responses": [
{
"uuid": "4fff0822-2407-44cf-b4db-1ba56926ec1e",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "4acc8511-8910-4bdc-8674-c5524bc29258",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/planning_result",
"responses": [
{
"uuid": "c1934a62-6703-40f3-b78b-1895dc2e8601",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "fcb526c2-b16a-4346-96f0-b60e885ef550",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "request/wcs/single_class_depal_task/report_action_status",
"responses": [
{
"uuid": "60177bd1-b23f-4b78-9f3e-f87aad9531fd",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "37a68e6d-e9eb-4688-8ce6-a019d86bf900",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "request/wcs/single_class_depal_task/report_action_status",
"responses": [
{
"uuid": "0d67abd5-6082-42dc-8632-a18a6f128f4c",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "50b22b17-c01b-4858-be40-a56f36e68555",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/cycle_result",
"responses": [
{
"uuid": "f55f7b58-ee21-4af4-ae0f-031ebebe049b",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "adc30fe0-8ba3-4395-9f06-84ac09eabab5",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/cycle_result",
"responses": [
{
"uuid": "de9a707d-22ca-4f66-a7c9-44d16cd34cc2",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "29078cc7-db2a-4d96-b4e8-f93e8a037d4a",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "request/wcs/report_exception",
"responses": [
{
"uuid": "2c8e4ab0-4cc7-4b78-92dc-6b40720a5d21",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "8350a0c3-7daf-4c65-a0b9-68911edd1faa",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "request/wcs/report_exception",
"responses": [
{
"uuid": "d95e4e2a-b9c3-4451-ad1c-ccb313dca4c6",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "c21d962a-d0e6-4518-91d3-546fe07dcacd",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "request/wcs/single_class_pal_task/report_task_status",
"responses": [
{
"uuid": "c8f42d1d-bcb8-43ef-a4b6-fc38e7b5f9de",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "7ddbb5c0-694b-40c2-a904-c8fcff08d4e1",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "request/wcs/single_class_pal_task/report_task_status",
"responses": [
{
"uuid": "379febb9-69f7-4d91-a6ea-af3dfa370e94",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "8cd68ce1-1ad7-44a2-ab36-19fa06a5ca02",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/order_step_result",
"responses": [
{
"uuid": "861b0b54-74a8-4d36-96b3-d9317757c685",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "bcef24c2-e446-44df-b4ca-8e9fe24d55eb",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/order_step_result",
"responses": [
{
"uuid": "9707c546-47d2-43a2-8faa-aa96eceefba9",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "5e00eb33-cd93-4c1c-8e39-d1af4dde8854",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/workspace_status",
"responses": [
{
"uuid": "35c3183b-fa64-4808-a540-fb8fee25b564",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "9cc5fd42-84ec-41f1-8b8f-8d18cbf06ad2",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/workspace_status",
"responses": [
{
"uuid": "91b01cb9-4ebf-4c47-bd8d-d3ec160aae77",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "73a2b43e-78d9-4bd8-a661-79d73ad4898f",
"type": "http",
"documentation": "Api",
"method": "get",
"endpoint": "api/order_result",
"responses": [
{
"uuid": "40c1f453-2072-49a9-92f3-00c648840c92",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
},
{
"uuid": "883f7bdb-0a15-4b53-ab21-4415a04c00b0",
"type": "http",
"documentation": "Api",
"method": "post",
"endpoint": "api/order_result",
"responses": [
{
"uuid": "fba52c35-abe2-488e-b113-0f52a8408738",
"body": "\"\"",
"latency": 0,
"statusCode": 200,
"label": "Successful Response",
"headers": [
{
"key": "Content-Type",
"value": "application/json"
}
],
"bodyType": "INLINE",
"filePath": "",
"databucketID": "",
"sendFileAsBody": false,
"rules": [],
"rulesOperator": "OR",
"disableTemplating": false,
"fallbackTo404": false,
"default": true,
"crudKey": "id"
}
],
"enabled": true,
"responseMode": null
}
],
"rootChildren": [
{
"type": "route",
"uuid": "07648d7b-0402-4cff-bb5f-71f9dbc5d10e"
},
{
"type": "route",
"uuid": "5f426281-d0b4-47b1-9d1f-3f15a9919323"
},
{
"type": "route",
"uuid": "e78d7ce7-94a4-4e94-86c2-d2adf7447085"
},
{
"type": "route",
"uuid": "a4e79864-050a-49dd-8a79-cf2ede55881d"
},
{
"type": "route",
"uuid": "58bd1039-b751-4a58-96cd-9660e3428a4f"
},
{
"type": "route",
"uuid": "62ff6cb8-b392-41ff-9cc4-f9150a81d84c"
},
{
"type": "route",
"uuid": "67d7e04c-3efc-4a69-9cda-681a834a7cf6"
},
{
"type": "route",
"uuid": "f3bfe8a7-e759-4d5e-a92b-8c019fb3bf20"
},
{
"type": "route",
"uuid": "1b5a19d7-4b39-432f-acd4-a3eb1524a38d"
},
{
"type": "route",
"uuid": "0a62a329-49d7-40a1-b255-352ddb625386"
},
{
"type": "route",
"uuid": "9fee32c4-89ec-478c-9bfe-dd8aeaef9a39"
},
{
"type": "route",
"uuid": "4acc8511-8910-4bdc-8674-c5524bc29258"
},
{
"type": "route",
"uuid": "fcb526c2-b16a-4346-96f0-b60e885ef550"
},
{
"type": "route",
"uuid": "37a68e6d-e9eb-4688-8ce6-a019d86bf900"
},
{
"type": "route",
"uuid": "50b22b17-c01b-4858-be40-a56f36e68555"
},
{
"type": "route",
"uuid": "adc30fe0-8ba3-4395-9f06-84ac09eabab5"
},
{
"type": "route",
"uuid": "29078cc7-db2a-4d96-b4e8-f93e8a037d4a"
},
{
"type": "route",
"uuid": "8350a0c3-7daf-4c65-a0b9-68911edd1faa"
},
{
"type": "route",
"uuid": "c21d962a-d0e6-4518-91d3-546fe07dcacd"
},
{
"type": "route",
"uuid": "7ddbb5c0-694b-40c2-a904-c8fcff08d4e1"
},
{
"type": "route",
"uuid": "8cd68ce1-1ad7-44a2-ab36-19fa06a5ca02"
},
{
"type": "route",
"uuid": "bcef24c2-e446-44df-b4ca-8e9fe24d55eb"
},
{
"type": "route",
"uuid": "5e00eb33-cd93-4c1c-8e39-d1af4dde8854"
},
{
"type": "route",
"uuid": "9cc5fd42-84ec-41f1-8b8f-8d18cbf06ad2"
},
{
"type": "route",
"uuid": "73a2b43e-78d9-4bd8-a661-79d73ad4898f"
},
{
"type": "route",
"uuid": "883f7bdb-0a15-4b53-ab21-4415a04c00b0"
}
],
"proxyMode": false,
"proxyHost": "",
"proxyRemovePrefix": false,
"tlsOptions": {
"enabled": false,
"type": "CERT",
"pfxPath": "",
"certPath": "",
"keyPath": "",
"caPath": "",
"passphrase": ""
},
"cors": true,
"headers": [],
"proxyReqHeaders": [
{
"key": "",
"value": ""
}
],
"proxyResHeaders": [
{
"key": "",
"value": ""
}
],
"data": []
}
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\globals.py | """全局对象."""
from wcs_adaptor.entity import Workspace
from xyz_max_hmi_server import (
MessagePusher,
OrderManager,
TaskManager,
WorkspaceManager,
)
from xyz_max_hmi_server.entity.order import LiteOrder
from xyz_max_hmi_server.entity.task import LiteTask
from xyz_max_hmi_server.globals import current_cycle, wcs_status
# 消息推送
mp = MessagePusher()
# 任务管理器
task_manager: TaskManager[LiteTask] = TaskManager()
# 订单管理器
order_manager: OrderManager[LiteOrder] = OrderManager()
# 工作空间管理器
workspace_manager: WorkspaceManager[Workspace] = WorkspaceManager[Workspace]()
__all__ = [
"current_cycle",
"mp",
"order_manager",
"task_manager",
"wcs_status",
"workspace_manager",
]
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\listener.py | """监听函数"""
from typing import List
from wcs_adaptor import globals
from wcs_adaptor.workflows import workflow
from xyz_max_hmi_server import g, logger, notify, plc_manager
from xyz_max_hmi_server.modules.monitor import Listener # noqa: F401
from xyz_max_hmi_server.utils.vp import vp_utils
# NOTE:
# 下方定义的函数是内置的常用监听器的回调函数，是否启用内置监听器可以在配置文件中进行配置
# 以下内置函数中的代码可以根据实际需求进行修改，但是请勿修改函数名
def handle_vp_status():
"""检查 VP 状态"""
from xyz_max_hmi_server.globals import system_status
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
tm = TaskManager()
# 如果 VP 有任何一个流图正在运行
if vp_utils.is_any_running():
# 任务管理器中的可执行任务数量为 0 时，设置系统状态为就绪，否则设置为运行中
if tm.count_executable() == 0:
system_status.set_ready()
else:
system_status.set_running()
else:
system_status.set_stopped()
def handle_wcs_status():
"""检查 WCS 状态"""
# 向 WCS 发送请求，如果成功则设置为已连接, 否则设置为未连接
if workflow.callback_health_check():
globals.wcs_status.set_connected()
else:
globals.wcs_status.set_disconnected()
def handle_estop():
"""处理急停"""
logger.debug("正在处理急停信号")
try:
# 停止 VP
vp_utils.stop()
# 停止机械臂
plc_manager.robot.stop()
except Exception as e:
raise Exception("处理急停信号时发生错误") from e
logger.debug("急停信号处理完成")
def handle_robot_connection_status():
"""机械臂连接状态"""
from xyz_max_hmi_server import MaxClient
client = MaxClient()
results = client.get_robot_status()
connected: List[int] = []
disconnected: List[int] = []
for result in results:
status = result["connection_status"]
if status is True:
connected.append(result["id"])
else:
disconnected.append(result["id"])
_old_status = g.get("robot_connection_status", 0)
content = []
if connected and not disconnected:
_status = 1
content.append('# 机械臂连接状态: <font color="info">连接正常</font>')
elif not connected and disconnected:
_status = 2
content.append('# 机械臂连接状态: <font color="warning">连接已断开</font>')
elif connected and disconnected:
_status = 3
content.append('# 机械臂连接状态: <font color="warning">部分连接失败</font>')
else:
_status = 0
content.append('# 机械臂连接状态: <font color="comment">无机械臂</font>')
if connected:
_t = [str(i) for i in connected]
content.append("## 已连接: {}".format(", ".join(_t)))
else:
content.append("## 已连接: 无")
if disconnected:
_t = [str(i) for i in disconnected]
content.append("## 未连接: {}".format(", ".join(_t)))
else:
content.append("## 未连接: 无")
if _status != _old_status:
message = "\n".join(content)
notify.notify_markdown(message)
g.set("robot_connection_status", _status, persist=False)
# NOTE:
# 对于一些标准库无法覆盖的场景，可能需要你自定义监听器。
# 自定义监听器你只用明确每一次循环做什么，每次间隔多久即可，监听器会自动开始循环执行。
# 使用 `@Listener.register` 装饰器进行装饰一个函数即可，该函数将会被作为监听器的回调函数。
# `name` 参数用于指定监听器的名称，`interval` 参数用于指定监听器的循环间隔，单位为秒。
# 以下的例子中，其含义就是每隔 1 秒钟执行一次 `plc_status` 函数，即每隔 1 秒钟读取一次地址为 120 的值。
# @Listener.register(name="plc_status", interval=1)
# def plc_status():
# from xyz_max_hmi_server.modules.plc import PLC
# address = 120
# result = PLC().read_signal(address)
# print(result)
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\main.py | from fastapi.exceptions import RequestValidationError
from fastapi.requests import Request
from loguru import logger
from wcs_adaptor import version
from wcs_adaptor.api.max import router as max_router
from wcs_adaptor.api.wcs import router as wcs_router
from wcs_adaptor.api.wcs_xlhb import * # noqa: F403
from xyz_max_hmi_server import Application
from xyz_max_hmi_server.error_handlers import display_validation_error
from xyz_max_hmi_server.exceptions import (
MAXException,
WCSException,
XYZException,
)
from xyz_max_hmi_server.responses import ErrorJSONResponse
from xyz_max_hmi_server.route import EnhancedAPIRoute
app = Application(
title="WCS Adaptor",
version=version.__version__,
description="WCS Adaptor",
)
app.router.route_class = EnhancedAPIRoute
# 提供给 MAX-Studio 的 API
app.include_router(max_router, prefix="/api/max")
# 提供给 WCS 的 API
app.include_router(wcs_router, prefix="/api/wcs")
@app.errorhandler(RequestValidationError)
def handler_validation_error(
request: Request, e: RequestValidationError
) -> "ErrorJSONResponse":
"""处理数据格式验证失败的异常."""
return ErrorJSONResponse(
msg="Unprocessable Entity",
data={
"error_code": 422,
"error_msg": display_validation_error(e),
"details": e.errors(),
},
)
@app.errorhandler(Exception)
def handler_exception(request: Request, e: Exception):
"""用于未知异常的处理"""
request.state.is_error_happened = True
if isinstance(e, MAXException):
return handler_max_exception(request, e)
elif isinstance(e, WCSException):
return handler_wcs_exception(request, e)
elif isinstance(e, XYZException):
return ErrorJSONResponse(
msg="XYZException",
data={"error_code": e.error_code, "error_msg": e.error_message},
)
else:
# FIXME:logger.exception 没有输出堆栈信息
logger.exception(e)
# 其他 API
return ErrorJSONResponse(
msg="Internal Server Error",
data={"error_code": 500, "error_msg": "内部错误，请联系管理员"},
)
def handler_wcs_exception(
request: Request, e: WCSException
) -> ErrorJSONResponse:
"""用于 WCS API 的异常处理"""
return ErrorJSONResponse(
msg=e.name,
data={
"error_code": e.error_code,
"error_msg": e.error_message,
},
)
def handler_max_exception(
request: Request, e: MAXException
) -> ErrorJSONResponse:
"""用于 MAX API 的异常处理"""
return ErrorJSONResponse(
msg=e.name,
data={
"error_code": e.error_code,
"error_msg": e.error_message,
},
)
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\mock.py | import os
import random
import uuid
from loguru import logger
from wcs_adaptor.entity import CMCPTask, Task
from wcs_adaptor.globals import task_manager
from xyz_max_hmi_server import db, enums
from xyz_max_hmi_server.entity.order import CMCPOrder
from xyz_max_hmi_server.utils.decorators import skip
def is_skip(*args, **kwargs) -> bool:
if os.getenv("MAX_HMI_ENV") == "mock":
return False
return True
@skip(condition=is_skip)
def mock_report_order_finish(task: "Task"):
"""模拟向上游反馈订单完成"""
from wcs_adaptor.workflows import workflow
for _ in range(task.target_num):
task.start()
task.report_pick_num(1, session=db.session)
workflow.callback_one_cycle_finish(task, 1)
order = task.order
if order is not None:
order.finish()
workflow.callback_order_finish(order) # type: ignore
db.session.commit()
logger.info("[Mock] 回报订单完成")
@skip(condition=is_skip)
def mock_report_planning_result(order: "CMCPOrder"):
"""模拟向上游反馈任务规划结果"""
from wcs_adaptor.workflows import cmcp_workflow
for inx, pre_task in enumerate(order.pre_tasks):
task = CMCPTask(
task_id=str(uuid.uuid4()),
task_type=enums.TaskType.CONTROLLED_SEQ_MCP,
order_id=order.order_id,
sku_info=pre_task.sku_info,
target_num=1,
from_ws=pre_task.from_options[0],
to_ws=pre_task.to_options[0],
pallet_idx=random.randint(0, len(pre_task.to_options) - 1),
serial_num=inx,
)
task_manager.receive(task)
cmcp_workflow.callback_planning_result(order)
logger.info("[Mock] 回报WCS任务规划结果")
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\api\max.py | """提供给 MAX-Studio 的 API"""
from typing import Literal, Optional
from fastapi import Path
from wcs_adaptor.entity.task import XLHBTask
from wcs_adaptor.globals import order_manager, task_manager
from wcs_adaptor.schemas import (
ErrorDetailSchema,
OrderInfoOutputSchema,
OrderSKUListOutputSchema,
ReportErrorInputSchema,
ReportPlanningResultInputSchema,
ReportTaskEndingInputSchema,
ReportTaskStatusInputSchema,
ReportTaskStatusInputV2Schema,
ReportTaskStatusOutputSchema,
TaskInfoOutputSchema,
WorkspaceOutputSchema,
WorkspaceUpdateSchema,
)
from wcs_adaptor.workflows import (
cmcp_workflow,
cmcp_workflow_pallet,
mcd_workflow,
rmcp_workflow,
rockydual_unloading_workflow,
sd_workflow,
sp_workflow,
workflow,
xlhb_sd_workflow,
xlhb_sp_workflow,
)
from xyz_max_hmi_server import Body, EnhancedAPIRouter, Std, enums
from xyz_max_hmi_server.exceptions import MAXException, XYZNotFoundError
from xyz_max_hmi_server.modules.error_records import record_vision_error
from xyz_max_hmi_server.schemas.arrival_sequence import BoxDimension
from xyz_max_hmi_server.schemas.base import List
router = EnhancedAPIRouter(tags=["Max"])
@router.post(
"/get_task_info",
response_model=Std[TaskInfoOutputSchema],
response_model_exclude_none=True,
name="获取第一个待执行的任务",
)
def get_task_info():
"""获取单个抓取Cycle任务及SKU信息的接口.
准确来讲，这个接口是 **开始执行任务** 的接口.
通过这个接口拿到任务就立即开始执行任务
"""
task = task_manager.first()
if not task:
return TaskInfoOutputSchema()
if task.task_type == enums.TaskType.SINGLE_PAL:
if isinstance(task, XLHBTask):
return xlhb_sp_workflow.max_get_task_info()
else:
return sp_workflow.max_get_task_info()
elif task.task_type == enums.TaskType.SINGLE_DEPAL:
if isinstance(task, XLHBTask):
return xlhb_sd_workflow.max_get_task_info()
else:
return sd_workflow.max_get_task_info()
elif task.task_type == enums.TaskType.RANDOM_SEQ_MCP:
return rmcp_workflow.max_get_task_info()
elif task.task_type == enums.TaskType.CONTROLLED_SEQ_MCP:
order = task.order
if order and order.supply_pallet_budget == -1:
return cmcp_workflow.max_get_task_info()
else:
return cmcp_workflow_pallet.max_get_task_info()
elif task.task_type == enums.TaskType.ROCKYDUAL_TRUCK_UNLOADING:
return rockydual_unloading_workflow.max_get_task_info()
elif task.task_type == enums.TaskType.MCD:
return mcd_workflow.max_get_task_info()
else:
raise MAXException("不支持的任务类型")
@router.post(
"/get_next_task",
name="获取下一个待来料的任务(控序混码)",
tags=["混码"],
response_model=Std[TaskInfoOutputSchema],
response_model_exclude_none=True,
)
def get_next_task():
"""获取下一个待来料的任务(控序混码)"""
try:
current_task = task_manager[0]
except XYZNotFoundError:
return TaskInfoOutputSchema()
order = current_task.order
if not order:
raise MAXException("当前没有订单")
if order.supply_pallet_budget == -1:
return cmcp_workflow.max_get_next_task()
else:
return cmcp_workflow_pallet.max_get_next_task()
@router.post(
"/get_order_info",
response_model=Std[OrderInfoOutputSchema],
response_model_exclude_none=True,
name="获取第一个待执行的订单信息",
)
def get_order_info():
return workflow.max_get_order_info()
@router.get(
"/order/{order_id}/sku",
name="获取订单的SKU信息列表",
response_model=Std[OrderSKUListOutputSchema],
response_model_exclude_none=True,
)
def get_order_sku_list(order_id: str):
"""获取订单的SKU信息列表."""
return workflow.max_get_order_sku_list(order_id)
@router.post(
"/order/complete",
tags=["订单"],
name="订单完成",
response_model=Std,
)
def complete_order(
order_id: Optional[str] = Body(default=None, embed=True, title="订单ID")
):
"""订单完成.
Args:
order_id: 订单ID，如果不传则默认取第一个订单
"""
if order_id is None:
order = order_manager.first()
if order is None:
raise MAXException("当前没有订单")
else:
order = order_manager.get_order_or_404(order_id)
funcs = {
enums.OrderType.SINGLE_PAL: sp_workflow.max_complete_order,
enums.OrderType.SINGLE_DEPAL: sd_workflow.max_complete_order,
enums.OrderType.CONTROLLED_SEQ_MCP: cmcp_workflow.max_complete_order,
enums.OrderType.RANDOM_SEQ_MCP: rmcp_workflow.max_complete_order,
enums.OrderType.ROCKYDUAL_TRUCK_UNLOADING: rockydual_unloading_workflow.max_complete_order,
}
func = funcs.get(order.order_type, None)
if func is None:
raise MAXException("该订单类型不支持该接口")
return func(order)
@router.post(
"/ws",
response_model=Std[WorkspaceOutputSchema],
name="查询工作空间是否就绪",
)
def get_workspace(ws_id: str = Body(embed=True, title="工作区ID")):
"""查询抓取工作空间是否就位."""
return workflow.max_get_workspace(ws_id)
@router.post(
"/ws/status",
response_model=Std,
name="更新工作空间状态",
)
def update_workspace(body: WorkspaceUpdateSchema):
"""更新抓取工作空间状态."""
return workflow.max_update_workspace(body)
@router.post(
"/report_task_status",
response_model=Std[ReportTaskStatusOutputSchema],
name="上报任务状态",
)
def report_task_status(body: ReportTaskStatusInputSchema):
"""回报任务状态."""
task = task_manager.get_task_or_404(body.task_id)
if task.task_type == enums.TaskType.CONTROLLED_SEQ_MCP:
order = task.order
if not order:
raise MAXException("订单不存在")
if order.supply_pallet_budget == -1:
return cmcp_workflow.max_report_task_status(body)
else:
return cmcp_workflow_pallet.max_report_task_status(body)
if task.task_type == enums.TaskType.SINGLE_PAL:
if isinstance(task, XLHBTask):
return xlhb_sp_workflow.max_report_task_status(body)
else:
return sp_workflow.max_report_task_status(body)
elif task.task_type == enums.TaskType.SINGLE_DEPAL:
if isinstance(task, XLHBTask):
return xlhb_sd_workflow.max_report_task_status(body)
else:
return sd_workflow.max_report_task_status(body)
elif task.task_type == enums.TaskType.ROCKYDUAL_TRUCK_UNLOADING:
return rockydual_unloading_workflow.max_report_task_status(body, task) # type: ignore
elif task.task_type == enums.TaskType.MCD:
return mcd_workflow.max_report_task_status(body)
else:
raise MAXException("不支持的任务类型")
@router.post(
"/v2/report_task_status",
response_model=List[ReportTaskStatusOutputSchema],
name="上报任务状态(V2)",
)
def report_task_status_v2(body: ReportTaskStatusInputV2Schema):
task = task_manager.get_task_or_404(body.results[0].task_id)
if task.task_type == enums.TaskType.CONTROLLED_SEQ_MCP:
order = task.order
if not order:
raise MAXException("订单不存在")
if order.supply_pallet_budget == -1:
return cmcp_workflow.max_report_task_status_v2(body)
else:
return cmcp_workflow_pallet.max_report_task_status_v2(body)
func_maps = {
enums.TaskType.SINGLE_PAL: sp_workflow.max_report_task_status_v2,
enums.TaskType.SINGLE_DEPAL: sd_workflow.max_report_task_status_v2,
enums.TaskType.RANDOM_SEQ_MCP: rmcp_workflow.max_report_task_status_v2,
}
return func_maps[task.task_type](body)
@router.post(
"/report_task_ending",
response_model=Std,
name="上报任务结束",
)
def report_task_ending(body: ReportTaskEndingInputSchema):
"""回报任务结束.
回报任务结束后，即向 WCS 回报订单结束.
"""
current_task = task_manager.first_or_404()
if current_task.task_type == enums.TaskType.CONTROLLED_SEQ_MCP:
order = current_task.order
if not order:
raise MAXException("订单不存在")
if order.supply_pallet_budget == -1:
return cmcp_workflow.max_report_task_ending(body)
else:
return cmcp_workflow_pallet.max_report_task_ending(body)
elif current_task.task_type == enums.TaskType.RANDOM_SEQ_MCP:
return rmcp_workflow.max_report_task_ending(body)
elif current_task.task_type == enums.TaskType.SINGLE_PAL:
if isinstance(current_task, XLHBTask):
return xlhb_sp_workflow.max_report_task_ending(body)
else:
return sp_workflow.max_report_task_ending(body)
elif current_task.task_type == enums.TaskType.SINGLE_DEPAL:
if isinstance(current_task, XLHBTask):
return xlhb_sd_workflow.max_report_task_ending(body)
else:
return sd_workflow.max_report_task_ending(body)
elif current_task.task_type == enums.TaskType.ROCKYDUAL_TRUCK_UNLOADING:
return rockydual_unloading_workflow.max_report_task_ending(body)
elif current_task.task_type == enums.TaskType.MCD:
return mcd_workflow.max_report_task_ending(body)
else:
raise MAXException("不支持的任务类型")
@router.post(
"/report_error",
response_model=Std,
name="上报错误",
)
def report_error(body: ReportErrorInputSchema):
"""上报错误."""
return workflow.max_report_error(body)
@router.post(
"/mcp/get_unplanned_order",
response_model=Std[OrderInfoOutputSchema],
response_model_exclude_none=True,
name="获取未规划完成的订单",
tags=["混码"],
)
def get_unplanned_order():
"""仅用于控序混码，用于获取未规划的订单"""
return cmcp_workflow.max_get_unplanned_order()
@router.post(
"/mcp/report_planning_result",
response_model=Std,
name="上报规划结果",
tags=["混码"],
)
def report_planning_result(body: ReportPlanningResultInputSchema):
"""仅用于控序混码，用于 VP 上报规划结果."""
order = order_manager.get_order_or_404(body.order_id)
if order.supply_pallet_budget == -1:
# 输送线
return cmcp_workflow.max_report_planning_result(body)
else:
# 托盘
return cmcp_workflow_pallet.max_report_planning_result(body)
@router.get(
"/mcp/arrival_sequence/first_unchecked",
name="获取第一个未检测的箱子信息",
tags=["混码"],
response_model=Std,
response_model_exclude_none=True,
)
def get_first_unchecked():
"""获取第一个未检测的箱子信息."""
result = cmcp_workflow.max_get_first_unchecked()
if not result:
return {"result": False}
return {
"result": True,
**result,
}
@router.post(
"/mcp/arrival_sequence/{sequence_id}/check_result",
response_model=Std,
name="上报检测结果",
tags=["混码"],
)
def report_check_result(
sequence_id: int = Path(..., ge=1, title="Sequence id"),
is_match: bool = Body(..., embed=True, title="是否匹配"),
actual_box_size: BoxDimension = Body(..., embed=True, title="实际箱子尺寸"),
):
"""上报检测结果."""
return cmcp_workflow.max_report_check_result(
sequence_id=sequence_id,
is_match=is_match,
actual_box_size=actual_box_size,
)
@router.get(
"/mcp/cmcp2rmcp/is_convert",
name="获取上游是否转无序混码",
response_model=Std,
tags=["混码"],
)
def get_is_convert():
"""获取上游是否转无序混码."""
return cmcp_workflow.max_cmcp2rmcp_is_convert()
@router.post(
"/mcp/cmcp2rmcp/",
name="处理控序转无序",
response_model=Std,
tags=["混码"],
)
def handle_cmcp2rmcp(
handle_method: Literal[
"immediately",
"delayed",
"cancel",
] = Body(..., embed=True, title="处理方式")
):
"""处理控序混码转无序混码.
Args:
handle_method: 处理方式, 可选值为: "immediately", "delayed", "cancel"
immediately: 立即转换, 立即转为无序混码
delayed: 延迟转换, 直到当前箱子被抓取时才转换
cancel: 取消转换, 中止订单
"""
return cmcp_workflow.max_handle_cmcp2rmcp(handle_method)
@router.post(
"/rockydual/get_container_info",
tags=["Rockydual"],
response_model=Std,
name="获取车厢信息",
)
def get_container_info():
"""获取车厢信息"""
return rockydual_unloading_workflow.max_get_container_info()
@router.post(
"/report_local_helper",
name="【已弃用】，记录视觉异常",
response_model=Std,
deprecated=True,
)
def report_local_helper():
"""已弃用. 记录 local helper."""
task = task_manager.first_or_404()
record_vision_error(task=task)
return {}
@router.get(
"/error/{error_code}",
name="【已弃用】，获取错误详情",
response_model=Std[ErrorDetailSchema],
deprecated=True,
)
def get_error(error_code: str):
"""已弃用. 获取错误详情."""
raise MAXException(
error_message=f"错误码({error_code})不存在"
).disable_msg_event()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\api\wcs.py | """WCS 适配器接口.
对外接口
"""
from typing import Any, Dict
from fastapi import BackgroundTasks
from loguru import logger
from wcs_adaptor.entity.task import Task
from wcs_adaptor.globals import (
mp,
order_manager,
task_manager,
workspace_manager,
)
from wcs_adaptor.schemas import (
OrderArriveSchema,
OrderBatchArriveSchema,
OrderCreateSchema,
SingleCreateSchema,
SingleDepalletizeCreateSchema,
SinglePalletizeCreateSchema,
)
from wcs_adaptor.workflows import (
cmcp_workflow,
cmcp_workflow_pallet,
mcd_workflow,
rmcp_workflow,
rockydual_unloading_workflow,
sd_workflow,
sp_workflow,
workflow,
)
from xyz_max_hmi_server import Body, EnhancedAPIRouter, _, enums
from xyz_max_hmi_server.entity.order import Order
from xyz_max_hmi_server.exceptions import XYZNotFoundError, XYZValidationError
from xyz_max_hmi_server.schemas.base import Std
router = EnhancedAPIRouter(tags=["WCS"])
@router.post(
"/workspace/ready",
name="工作空间已就绪",
response_model=Dict[str, Any],
)
def workspace_ready(
ws_id: str = Body(..., embed=True, example="1", title="工作空间ID", alias="id")
):
"""工作空间已就绪(更换托盘)."""
return workflow.wcs_workspace_ready(ws_id)
@router.post(
"/order",
tags=["订单"],
name="创建订单，支持单拆/单码/混拆/控序混码/无序混码/Rockydual装卸订单",
response_model=Dict[str, Any],
)
def create_order(body: OrderCreateSchema, bg_tasks: BackgroundTasks):
"""创建订单, 通用接口, 支持单拆/单码/混拆/控序混码/无序混码/Rockydual装卸订单.
创建各类型订单的示例:
- [单拆](https://xyz-robotics.atlassian.net/wiki/spaces/Training/pages/898629633#%E7%A4%BA%E4%BE%8B)
- [单码](https://xyz-robotics.atlassian.net/wiki/spaces/Training/pages/898629645#%E7%A4%BA%E4%BE%8B)
- [混拆](https://xyz-robotics.atlassian.net/wiki/spaces/Training/pages/951287809#%E7%A4%BA%E4%BE%8B)
- [控序混码(输送线来料)](https://xyz-robotics.atlassian.net/wiki/spaces/Training/pages/898662401#%E7%A4%BA%E4%BE%8B)
- [控序混码(托盘来料)](https://xyz-robotics.atlassian.net/wiki/spaces/Training/pages/920485889#%E7%A4%BA%E4%BE%8B)
- [无序混码](https://xyz-robotics.atlassian.net/wiki/spaces/Training/pages/908755729#%E7%A4%BA%E4%BE%8B)
- [Rockydual卸车](https://xyz-robotics.atlassian.net/wiki/spaces/Training/pages/940933122/RockyDual#%E7%A4%BA%E4%BE%8B)
"""
if body.order_type == enums.OrderType.SINGLE_DEPAL:
return sd_workflow.wcs_create_order(body)
elif body.order_type == enums.OrderType.SINGLE_PAL:
return sp_workflow.wcs_create_order(body)
elif body.order_type == enums.OrderType.CONTROLLED_SEQ_MCP:
return cmcp_workflow.wcs_create_order(body, bg_tasks)
elif body.order_type == enums.OrderType.RANDOM_SEQ_MCP:
return rmcp_workflow.wcs_create_order(body, bg_tasks)
elif body.order_type == enums.OrderType.ROCKYDUAL_TRUCK_UNLOADING:
return rockydual_unloading_workflow.wcs_create_order(body)
elif body.order_type == enums.OrderType.MCD:
return mcd_workflow.wcs_create_order(body)
else:
raise NotImplementedError(f"不支持的订单类型: {body.order_type}")
@router.post(
"/order/arrived",
tags=["订单", "混码"],
name="物料达到",
response_model=Dict[str, Any],
)
def order_arrived(body: OrderArriveSchema, bg_tasks: BackgroundTasks):
"""物料已到位, 目前仅支持控序混码订单."""
order_type = order_manager.get_type_by_order_id(body.order_id)
if order_type is None:
raise XYZNotFoundError(_("订单 '{0}' 不存在").format(body.order_id))
if order_type == enums.OrderType.CONTROLLED_SEQ_MCP:
return cmcp_workflow.wcs_order_arrived(body, bg_tasks)
else:
raise XYZValidationError(_("该订单类型不支持该接口"))
@router.post(
"/order/batch_arrived",
tags=["订单", "混码"],
name="批次物料达到",
response_model=Dict[str, Any],
)
def order_batch_arrived(
body: OrderBatchArriveSchema, bg_tasks: BackgroundTasks
):
"""批次物料已到位, 目前仅支持控序混码订单."""
order_type = order_manager.get_type_by_order_id(body.order_id)
if order_type is None:
raise XYZNotFoundError(_("订单 '{0}' 不存在").format(body.order_id))
if order_type == enums.OrderType.CONTROLLED_SEQ_MCP:
return cmcp_workflow_pallet.wcs_order_batch_arrived(body, bg_tasks)
else:
raise XYZValidationError(_("该订单类型不支持该接口"))
@router.post(
"/order/abort",
tags=["订单"],
name="中止订单",
response_model=Dict[str, Any],
)
def order_abort(order_id: str = Body(..., embed=True, title="订单ID")):
"""中止订单."""
# TODO: 判断当前系统处于运行中，则拒绝终止订单
order = order_manager.get_order_or_404(order_id)
funcs = {
enums.OrderType.SINGLE_PAL: sp_workflow.wcs_abort_order,
enums.OrderType.SINGLE_DEPAL: sd_workflow.wcs_abort_order,
enums.OrderType.CONTROLLED_SEQ_MCP: cmcp_workflow.wcs_abort_order,
enums.OrderType.RANDOM_SEQ_MCP: rmcp_workflow.wcs_abort_order,
enums.OrderType.ROCKYDUAL_TRUCK_UNLOADING: rockydual_unloading_workflow.wcs_abort_order,
}
func = funcs.get(order.order_type, None)
if func is None:
raise XYZValidationError(_("该订单类型不支持该接口"))
return func(order)
@router.post(
"/order/cmcp2rmcp/is_convert",
name="是否将控序混码转换为无序混码",
tags=["订单", "混码"],
response_model=Dict[str, Any],
)
def cmcp2rmcp_is_convert(
# order_id: str = Body(..., embed=True, title="订单ID"),
is_convert: bool = Body(..., embed=True, title="是否转换"),
):
"""控序混码转随机混码."""
return cmcp_workflow.wcs_cmcp2rmcp_is_convert(is_convert)
def create_single_task(schema: SingleCreateSchema) -> Task:
"""创建单拆/单码订单."""
task = Task.parse_obj(schema)
task.set_order_id(schema.task_id)
order = Order(
order_id=schema.task_id,
order_type=enums.OrderType(schema.task_type.value),
)
task_manager.append(task)
order_manager.append(order)
workspace_manager.create_or_modify(
ws_id=task.from_ws, is_ready=schema.clear_from_ws
)
workspace_manager.create_or_modify(
ws_id=task.to_ws, is_ready=schema.clear_to_ws
)
return task
# ---------
# 单拆接口
# ---------
@router.post(
"/task/single_depal",
tags=["订单"],
name="【已弃用】创建单拆订单/任务",
response_model=Std,
deprecated=True,
)
def single_class_depal_task(body: SingleDepalletizeCreateSchema):
"""创建单拆订单/任务, **已弃用**，请使用创建订单接口."""
try:
task = create_single_task(body)
message = _("已收到单拆订单({0})，待完成数量: {1}").format(
task.task_id, task.target_num
)
mp.order.info(message)
except Exception as e:
logger.exception(e)
mp.order.error("创建订单失败")
raise e
return {}
# ---------
# 单码接口
# ---------
@router.post(
"/task/single_pal",
tags=["订单"],
name="【已弃用】创建单码订单/任务",
response_model=Std,
deprecated=True,
)
def single_class_pal_task(body: SinglePalletizeCreateSchema):
"""创建单码订单/任务, **已弃用**，请使用创建订单接口.
Raises:
ValidationError: 接口参数输入异常.
TaskDuplicateError: 传入了重复的任务.
"""
try:
task = create_single_task(body)
message = _("已收到单码订单({0})，待完成数量: {1}").format(
task.task_id, task.target_num
)
mp.order.info(message)
except Exception as e:
logger.exception(e)
mp.order.error("创建订单失败")
raise e
return {}
@router.post(
"/task/terminate",
name="【已弃用】终止任务",
tags=["WCS"],
response_model=Dict[str, Any],
deprecated=True,
)
def terminate_task(task_id: str = Body(..., embed=True, title="任务ID")):
"""中止任务, **已弃用**，请使用中止订单接口."""
try:
order = order_manager.get_order_or_404(task_id)
except Exception:
return {
"error": -1,
"error_msg": "fail, order not found",
}
funcs = {
enums.OrderType.SINGLE_PAL: sp_workflow.wcs_abort_order,
enums.OrderType.SINGLE_DEPAL: sd_workflow.wcs_abort_order,
}
func = funcs.get(order.order_type, None)
if func is None:
raise XYZValidationError(_("该订单类型不支持该接口"))
return func(order)
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\api\wcs_xlhb.py | """老接口，兼容 xlhb 的接口."""
from typing import Any, Dict
from loguru import logger
from wcs_adaptor.globals import task_manager
from wcs_adaptor.schemas import (
SingleDepalletizeCreateSchema,
SinglePalletizeCreateSchema,
)
from wcs_adaptor.workflows import xlhb_sd_workflow, xlhb_sp_workflow
from xyz_max_hmi_server import Body, cached_app, enums, system_status
_app = cached_app()
@_app.post(
"/api/wcs/single_class_depal_task", name="创建单拆任务(兼容 XLHB)", tags=["XLHB"]
)
def single_class_depal_task_old(body: SingleDepalletizeCreateSchema):
"""创建单拆订单/任务."""
return xlhb_sd_workflow.wcs_create_task(body)
@_app.post(
"/api/wcs/single_class_pal_task", name="创建单码任务(兼容 XLHB)", tags=["XLHB"]
)
def single_class_pal_task_old(body: SinglePalletizeCreateSchema):
"""创建单码订单/任务."""
return xlhb_sp_workflow.wcs_create_task(body)
@_app.post("/api/wcs/terminate_task", name="终止任务(兼容 XLHB)", tags=["XLHB"])
def terminate_task(task_id: str = Body(..., embed=True, title="任务ID")):
"""中止任务."""
task = task_manager.get_task_or_404(task_id)
if task.task_type == enums.TaskType.SINGLE_DEPAL:
return xlhb_sd_workflow.wcs_abort_task(task_id)
elif task.task_type == enums.TaskType.SINGLE_PAL:
return xlhb_sp_workflow.wcs_abort_task(task_id)
else:
logger.error(f"不支持的任务类型: {task.task_type}")
return {
"error": -1,
"error_msg": "Unknown task type",
}
@_app.post(
"/api/wcs/is_system_ready",
summary="获取系统状态(兼容 XLHB)",
response_model=Dict[str, Any],
tags=["XLHB"],
)
async def get_system_status():
"""获取系统状态
该接口用于获取系统状态，返回值为枚举类型，具体值如下：
0: 就绪
1: 运行中
99: 异常/停止
"""
return {
"status": system_status.status,
"message": system_status.status.name.lower(),
}
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\entity\order.py | from xyz_max_hmi_server.entity.order import (
CMCPOrder,
LiteOrder,
MCDOrder,
MCPOrder,
Order,
RMCPOrder,
RockyDualLoadingOrder,
RockyDualUnloadingOrder,
)
__all__ = [
"CMCPOrder",
"LiteOrder",
"RMCPOrder",
"Order",
"MCPOrder",
"MCDOrder",
"RockyDualUnloadingOrder",
"RockyDualLoadingOrder",
]
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\entity\task.py | """Task entity."""
import copy
from typing import List, Optional, Union
from pydantic import BaseModel, Field, root_validator
from sqlalchemy.orm.session import Session
from typing_extensions import Final, Self, TypedDict
from xyz_max_hmi_server import LiteTask, crud, enums, services
from xyz_max_hmi_server.db.session import NEW_SESSION, provide_session
from xyz_max_hmi_server.entity.sku import SKUInfo
from xyz_max_hmi_server.exceptions import XYZException
from xyz_max_hmi_server.models.task_batch import TaskBatchModel
from xyz_max_hmi_server.schemas.arrival_sequence import ArrivalSequence
from xyz_max_hmi_server.schemas.task_batch import TaskBatchCreate
class Task(LiteTask):
"""General Task."""
from_ws: str = Field(title="抓取工作空间")
to_ws: str = Field(title="放置工作空间")
from_options: List[str] = Field(
default_factory=list, title="可使用的抓取位", alias="from"
)
to_options: List[str] = Field(
default_factory=list, title="可使用的放置位", alias="to"
)
@root_validator(pre=True)
def _v(cls, values):
# HACK: 兼容单拆和单码任务
if values.get("from_ws") is None:
values["from_ws"] = values["from_options"][0]
if values.get("to_ws") is None:
values["to_ws"] = values["to_options"][0]
return values
class XLHBTask(Task):
"""兼容 XLHB 的任务类，方便区分"""
pass
class MCDTask(Task):
"""混拆任务"""
task_type: Final[enums.TaskType] = Field(
default=enums.TaskType.MCD, title="任务类型"
)
target_num: int = Field(
default=-1,
title="预估需要做的数量",
description="预估数量, -1 表示无数量限制, 拆空为止",
)
class Config: # noqa: D106
orm_mode = True
allow_population_by_field_name = True # 允许通过字段名进行赋值
class MCPTask(LiteTask):
"""Mixed Case Pallet Task."""
order_id: str = Field(..., title="订单编号")
from_ws: str = Field(default=None, title="抓取工作空间")
to_ws: str = Field(default=None, title="放置工作空间")
from_options: List[str] = Field(
default_factory=list, title="可使用的抓取位", alias="from"
)
to_options: List[str] = Field(
default_factory=list, title="可使用的放置位", alias="to"
)
batch_id: Optional[str] = Field(default=None, title="批次编号")
@root_validator
def _v(cls, values):
if values["from_options"]:
values["from_ws"] = values["from_options"][0]
if values["to_options"]:
values["to_ws"] = values["to_options"][0]
return values
def is_in_batch(self) -> bool:
"""判断当前任务是否属于某个批次."""
return self.batch_id is not None
@provide_session
def end(
self,
auto_remove: bool = True,
auto_complete: bool = True,
session: Session = NEW_SESSION,
) -> None:
"""结束任务的方法.
在原有的逻辑上，增加删除批次记录的逻辑。
"""
if self.batch_id:
crud.task_batch.remove_by_task_id_and_batch_id(
batch_id=self.batch_id,
task_id=self.task_id,
session=session,
)
return super().end(auto_remove, auto_complete, session)
@provide_session
def terminate(
self,
error: Union[str, XYZException, None] = None,
auto_remove: bool = True,
session: Session = NEW_SESSION,
) -> None:
"""中止任务的方法.
在原有的逻辑上，增加删除批次记录的逻辑。
"""
if self.batch_id:
crud.task_batch.remove_by_task_id_and_batch_id(
batch_id=self.batch_id,
task_id=self.task_id,
session=session,
)
return super().terminate(error, auto_remove, session)
@provide_session
def bind_batch(self, session: Session = NEW_SESSION) -> None:
"""将当前任务绑定到一个批次."""
if self.batch_id is None:
raise ValueError("当前任务的 'batch_id' 为 None，不能绑定批次")
crud.task_batch.create(
obj_in=TaskBatchCreate(
task_id=self.task_id,
batch_id=self.batch_id,
),
session=session,
)
@provide_session
def is_last_in_batch(self, session: Session = NEW_SESSION) -> bool:
"""判断当前任务是否为该批次的最后一个任务.
如果当前任务的批次编号为 None, 则返回 False.
"""
if self.batch_id is None:
return False
return crud.task_batch.count(self.batch_id, session=session) == 1
@provide_session
def next_task_in_batch(
self, session: Session = NEW_SESSION
) -> Optional[Self]:
"""获取当前任务所属批次的下一个任务.
如果当前任务的批次编号为 None, 则返回 None.
"""
if self.batch_id is None:
return None
cur_id = (
session.query(TaskBatchModel.id)
.filter(TaskBatchModel.task_id == self.task_id)
.scalar()
)
if cur_id is None:
return None
next_task_id = (
session.query(TaskBatchModel.task_id)
.filter(
TaskBatchModel.id > cur_id,
TaskBatchModel.batch_id == self.batch_id,
)
.limit(1)
.scalar()
)
if next_task_id is None:
return None
record = crud.task.get_by_task_id(task_id=next_task_id, session=session)
if record is None:
return None
return self.__class__.parse_obj(record.raw_data)
class RMCPTask(MCPTask):
"""Random Mixed Case Pallet Task."""
task_type: Final[enums.TaskType] = Field(
default=enums.TaskType.RANDOM_SEQ_MCP, title="任务类型"
)
@classmethod
def from_cmcp(
cls, order_id: str, sku_info: SKUInfo, arrival_sequence: ArrivalSequence
) -> Self:
"""从控序混码任务创建无序混码任务.
Args:
order_id (str): 订单编号
sku_info (SKUInfo): SKU 信息
arrival_sequence (ArrivalSequence): 控序混码来料序列
Returns:
RMCPTask: 无序混码任务
"""
return cls(
task_id=arrival_sequence.extra["task_id"],
order_id=order_id,
target_num=1,
sku_info=sku_info,
from_options=[arrival_sequence.extra["from_ws"]], # type: ignore
to_options=[arrival_sequence.extra["to_ws"]], # type: ignore
customized_data={
"sequence_id": arrival_sequence.id,
"__from_cmcp": True,
**arrival_sequence.extra["customized_data"],
},
)
def is_from_cmcp(self) -> bool:
"""判断当前任务是否来自于控序混码任务."""
return self.customized_data.get("__from_cmcp", False)
@provide_session
def finish(
self,
auto_remove: bool = True,
auto_complete: bool = True,
session: Session = NEW_SESSION,
) -> None:
"""标记任务完成.
标记任务完成的同时，将来料序列标记为完成
"""
if self.is_from_cmcp():
services.arrival_sequence.mark_as_complete(
self.customized_data["sequence_id"],
session=session,
)
return super().finish(auto_remove, auto_complete, session=session)
class CMCPTask(MCPTask):
"""Controlled Mixed Case Pallet Task."""
task_type: Final[enums.TaskType] = Field(
default=enums.TaskType.CONTROLLED_SEQ_MCP, title="任务类型"
)
pallet_idx: int = Field(..., title="托盘编号")
serial_num: int = Field(..., title="序号")
def to_rmcp(self) -> RMCPTask:
"""转换为无序混码任务."""
extra = copy.copy(self.customized_data)
extra["__from_cmcp"] = True
return RMCPTask(
task_id=self.task_id,
target_num=1,
order_id=self.order_id,
from_options=[self.from_ws], # type: ignore
to_options=[self.to_ws], # type: ignore
customized_data=extra,
)
class _ContainerDimension(TypedDict):
"""容器尺寸"""
length: float
width: float
height: float
class RockyDualUnloadingTask(LiteTask):
"""Rocky Dual Unloading Task."""
task_type: Final[enums.TaskType] = Field(
default=enums.TaskType.ROCKYDUAL_TRUCK_UNLOADING, title="任务类型"
)
sku_infos: List[SKUInfo] = Field(
default_factory=list, description="SKU 信息列表"
)
done_num: int = Field(default=0, description="已完成的数量", allow_mutation=False)
target_num: int = Field(default=-1, description="预估数量, -1 表示无数量限制")
license_plate_number: Optional[str] = Field(default=None, description="车牌号")
truck_inner_dimension: _ContainerDimension = Field(description="容器尺寸")
class RockyDualLoadingTask(LiteTask):
"""Rocky Dual Loading Task."""
task_type: Final[enums.TaskType] = Field(
default=enums.TaskType.ROCKYDUAL_TRUCK_LOADING, title="任务类型"
)
sku_infos: List[SKUInfo] = Field(
default_factory=list, description="SKU 信息列表"
)
done_num: int = Field(default=0, description="已完成的数量", allow_mutation=False)
target_num: int = Field(default=-1, description="预估数量, -1 表示无数量限制")
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\entity\workspace.py | from xyz_max_hmi_server.entity.workspace import Workspace
__all__ = ["Workspace"]
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\entity\__init__.py | from .order import CMCPOrder, LiteOrder, MCPOrder, Order
from .task import (
CMCPTask,
MCDTask,
MCPTask,
RMCPTask,
RockyDualUnloadingTask,
Task,
XLHBTask,
)
from .workspace import Workspace
__all__ = [
"Task",
"CMCPTask",
"RMCPTask",
"XLHBTask",
"MCPTask",
"MCDTask",
"Order",
"LiteOrder",
"MCPOrder",
"CMCPOrder",
"Workspace",
"RockyDualUnloadingTask",
]
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\schemas\max_schemas.py | from datetime import datetime
from typing import Dict, List, Literal, Optional
from pydantic import BaseModel, Field, root_validator, validator
from wcs_adaptor.entity import Task
from xyz_max_hmi_server import enums
from xyz_max_hmi_server.entity.cmcp_planning_result import Result
from xyz_max_hmi_server.entity.pre_task import PreTask
from xyz_max_hmi_server.entity.sku import SKUInfo
class SKUInfoOutputSchema(SKUInfo):
"""SKU信息的输出模型."""
pass
class TaskInfoOutputSchema(BaseModel):
"""获取任务信息的输出模型."""
result: bool = Field(default=False, title="是否有任务")
task_id: Optional[str] = Field(default=None, title="任务编号")
task_status: Optional[enums.TaskStatus] = Field(default=None, title="任务状态")
task_type: Optional[enums.TaskType] = Field(default=None, title="任务类型")
from_ws: Optional[str] = Field(default=None, title="抓取位工作空间编号")
to_ws: Optional[str] = Field(default=None, title="放置位工作空间编号")
sku_info: Optional[SKUInfoOutputSchema] = Field(default=None, title="SKU信息")
target_num: Optional[int] = Field(default=None, title="预计抓取数量")
done_num: Optional[int] = Field(default=None, title="已完成数量")
undone_num: Optional[int] = Field(default=None, title="剩余的数量")
max_num: Optional[int] = Field(default=1, title="机械臂一次能抓取的最大数量")
clear_from_ws: bool = Field(default=False, title="抓取位是否已清空")
clear_to_ws: bool = Field(default=False, title="放置位是否已清空")
customized_data: dict = Field(default_factory=dict, title="自定义数据")
@validator("max_num")
def validate_max_num(cls, v: Optional[int], values: dict) -> Optional[int]:
if values["result"] is False:
return None
if values["task_type"] == enums.TaskType.MCD: # 混拆项目, 无目标拆垛数
v = 1
else: # 其他项目, 比较下一次拆(码)允许最大数量
if values["target_num"] > 0:
v = min(1, values["undone_num"])
else:
v = 1
return v
@validator("sku_info")
def convert_unit(cls, v: Optional[SKUInfo]) -> Optional[SKUInfo]:
"""将mm转换为m."""
if v is None:
return v
return v.to_m().to_kg()
class Config:
schema_extra = {
"required": [
"result",
"clear_from_ws",
"clear_to_ws",
"customized_data",
]
}
class OrderInfoOutputSchema(BaseModel):
"""获取订单信息的输出模型."""
result: bool = Field(default=False, title="是否有订单")
order_id: Optional[str] = Field(default=None, title="订单ID")
order_type: Optional[enums.OrderType] = Field(
default=None, title="订单类型", description="订单类型"
)
order_status: Optional[enums.OrderStatus] = Field(
default=None, title="订单状态"
)
create_time: Optional[datetime] = Field(default=None, description="创建时间")
tasks: Optional[List[dict]] = Field(
default_factory=list,
title="任务列表",
description="任务列表",
)
customized_data: Dict = Field(default_factory=dict, description="自定义字典")
# NOTE: 以下字段为可选字段
pre_tasks: Optional[List[PreTask]] = Field(
defualt=None,
title="预处理任务列表",
description="用于控序混码规划",
)
global_barcode_direction: Optional[int] = Field(
default=None, title="全局条码方向"
)
time_budget: Optional[int] = Field(
default=None,
title="最大规划时间",
description="最大规划时间，单位：秒, -1 表示不限制, 直到规划完成",
)
place_pallet_budget: Optional[int] = Field(
default=None,
title="最多放置托盘数",
description="最多放置托盘数, -1 表示不限制",
)
supply_pallet_budget: Optional[int] = Field(
default=None,
title="最多来料托盘数",
description="最多来料托盘数, -1 表示不限制",
)
planning_result_key: Optional[str] = Field(default=None, title="规划结果的唯一标识")
fix_order: Optional[bool] = Field(default=None)
@root_validator
def _v(cls, values):
if values.get("order_id") is not None:
values["result"] = True
return values
class Config:
schema_extra = {
"example": {
"order_id": "string",
"order_type": 4,
"order_status": 0,
"global_barcode_direction": -1,
"time_budget": -1,
"place_pallet_budget": -1,
"supply_pallet_budget": -1,
"planning_result_key": "xxxx",
"fix_order": False,
"create_time": "2023-07-18 14:28:50",
"pre_tasks": [
{
"task_id": "32f5232b-1cfe-4d96-a1ac-c2e31fb2c0b6",
"task_type": 4,
"from_options": ["0", "1"],
"to_options": ["2", "3"],
"target_num": 1,
"sku_info": {
"sku_id": "string",
"sku_type": "box",
"sku_num": 0,
"length": 11,
"width": 11,
"height": 1,
"weight": 1,
"weight_unit": "kg",
"length_unit": "mm",
"barcode_direction": 0,
"load_bearing": -1,
"direction_options": ["Ori", "RotZ"],
},
}
],
"tasks": [],
"customized_data": {},
},
}
class OrderSKUListOutputSchema(BaseModel):
"""订单的 SKU 列表输出模型"""
order_id: str = Field(..., title="订单编号")
skus: List[SKUInfoOutputSchema] = Field(..., title="SKU列表")
class WorkspaceUpdateSchema(BaseModel):
ws_ids: List[str] = Field(..., title="工作空间编号列表")
status: Literal["full", "empty"] = Field(..., title="工作空间状态")
class WorkspaceOutputSchema(BaseModel):
"""工作空间信息输出模型"""
ws_id: str = Field(..., title="工作空间编号")
is_ready: bool = Field(..., title="工作空间是否准备好")
is_new_pallet: bool = Field(..., title="是否新托盘")
class ReportTaskStatusInputSchema(BaseModel):
"""上报任务状态输入参数"""
task_id: str = Field(..., title="任务编号")
pick_num: int = Field(..., title="本次抓取数量")
drop_num: Optional[int] = Field(ge=0, title="掉落数量")
is_depal_pallet_empty: bool = Field(default=False, title="拆垛位是否已清空")
is_pal_pallet_full: bool = Field(default=False, title="码垛位是否已满")
customized_info: dict = Field(default_factory=dict, title="额外的数据")
class ReportTaskStatusResultSchema(BaseModel):
task_id: str = Field(..., title="任务编号")
pick_num: int = Field(default=0, title="本次抓取数量", ge=0)
drop_num: int = Field(default=0, title="掉落数量", ge=0)
class ReportTaskStatusInputV2Schema(BaseModel):
"""上报任务状态输入参数."""
action: enums.Action = Field(..., title="动作")
is_depal_pallet_empty: bool = Field(default=False, title="拆垛位是否已清空")
is_pal_pallet_full: bool = Field(default=False, title="码垛位是否已满")
is_in_buffer: bool = Field(default=False, title="是否在缓冲区")
from_ws: Optional[str] = Field(
default=None,
title="实际的抓取空间",
alias="from",
description="在无序混码场景中，实际的抓取位置由VP计算，所以允许VP告知最终的抓取空间",
)
to_ws: Optional[str] = Field(
default=None,
title="实际的放置空间",
alias="to",
description="在无序混码场景中，实际的放置位置由VP计算，所以允许VP告知最终的放置空间",
)
results: List[ReportTaskStatusResultSchema] = Field(..., title="任务状态列表")
customized_info: dict = Field(default_factory=dict, title="额外的数据")
class Config:
allow_population_by_field_name = True
schema_extra = {
"example": {
"action": "after_place",
"is_depal_pallet_empty": False,
"is_pal_pallet_full": False,
"is_in_buffer": False,
"from": "string",
"to": "string",
"results": [
{
"task_id": "string",
"pick_num": 1,
"drop_num": 0,
}
],
}
}
class ReportTaskStatusOutputSchema(BaseModel):
"""上报任务状态输出"""
task_id: str = Field(..., title="任务编号")
is_task_finished: bool = Field(..., title="任务是否完成")
is_order_finished: bool = Field(..., title="订单是否完成")
class ReportTaskEndingInputSchema(BaseModel):
task_id: Optional[str] = Field(default=None, title="任务ID")
task_ids: List[str] = Field(default_factory=list, title="任务ID列表")
customized_info: dict = Field(default_factory=dict, title="额外的数据")
@root_validator
def _v(cls, values):
if values["task_id"] is None and len(values["task_ids"]) == 0:
raise ValueError("task_id 和 task_ids 不能同时为空")
if values["task_id"] is not None:
values["task_ids"].append(values["task_id"])
values["task_ids"] = list(set(values["task_ids"]))
return values
class ReportErrorInputSchema(BaseModel):
"""上报错误信息输入参数"""
task_id: Optional[str] = Field(None, title="任务编号")
show_dialog: bool = Field(
True,
title="是否显示错误对话框",
deprecated=True,
)
error_code: str = Field(..., max_length=20, title="错误码")
error_msg: str = Field("", max_length=20000, title="错误信息")
tip: str = Field("", title="提示信息")
customized_info: dict = Field(default_factory=dict, title="额外的数据")
class ErrorDetailSchema(BaseModel):
"""错误详情."""
error_code: Optional[str] = Field(default=None, title="错误码")
msg: Optional[str] = Field(default=None, title="错误信息")
tip: Optional[str] = Field(default=None, title="错误提示")
class ReportPlanningResultInputSchema(BaseModel):
"""上报规划结果输入参数"""
order_id: str = Field(..., title="订单编号")
planning_result_key: str = Field(..., title="规划结果的唯一标识")
start_time: datetime = Field(..., title="规划开始时间")
end_time: datetime = Field(..., title="规划结束时间")
status: bool = Field(..., title="规划是否成功")
error_msg: Optional[str] = Field(default=None, title="错误信息")
results: List[Result] = Field(default_factory=list, title="规划结果")
customized_info: dict = Field(default_factory=dict, title="额外的数据")
@validator("start_time", "end_time", pre=True)
def timestamp_to_datetime(cls, v):
if isinstance(v, int):
# 如果 v 精确到毫秒，则转换为秒
if len(str(v)) == 13:
v = v / 1000
return datetime.fromtimestamp(v)
return v
@root_validator
def check_results(cls, values):
if not values["status"]:
if values["error_msg"] is None:
raise ValueError("规划失败时，error_msg 不能为空")
return values
return values
class Config:
allow_population_by_alias = True
schema_extra = {
"example": {
"order_id": "string",
"planning_result_key": "string",
"start_time": 1689736531938,
"end_time": 1689736532022,
"status": True,
"error_msg": "string",
"results": [
{
"sku_info": {
"id": "string",
"type": "box",
"length": 0.5,
"width": 0.4,
"height": 0.3,
"weight": 1,
"weight_unit": "kg",
"length_unit": "m",
"barcode_direction": 0,
"load_bearing": -1,
"direction_options": ["Ori", "RotZ"],
"pose": {
"position": {"x": 0, "y": 0, "z": 0},
"orientation": {"x": 0, "y": 0, "z": 0, "w": 0},
},
},
"from": "string",
"to": "string",
"pallet_idx": 0,
"serial_num": 0,
"customized_data": {},
}
],
}
}
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\schemas\wcs_schemas.py | import uuid
from typing import Final, List, Optional
from pydantic import BaseModel, Field, validator
from xyz_max_hmi_server import _, enums
from xyz_max_hmi_server.entity import PreTask, SKUInfo
class SKUInfoInputSchema(SKUInfo):
"""SKU信息输入模型."""
class Config:
extra_schema = {
"example": {
"id": "1",
"type": "box",
"length": 500,
"width": 400,
"height": 300,
"weight": 1,
"weight_unit": "kg",
"length_unit": "mm",
"barcode_direction": 0,
"load_bearing": -1,
"direction_options": ["Ori", "RotZ"],
},
}
class TaskCreateSchema(BaseModel):
task_id: str = Field(
default_factory=lambda: str(uuid.uuid4()), description="任务ID"
)
order_id: Optional[str] = Field(default=None, description="订单ID")
task_type: enums.TaskType = Field(..., description="任务类型")
from_options: List[str] = Field(
default=None,
description="可使用的抓取位",
alias="from",
)
to_options: List[str] = Field(
default=None,
description="可使用的放置位",
alias="to",
)
target_num: Optional[int] = Field(default=None, description="任务数量")
sku_info: Optional[SKUInfoInputSchema] = Field(
default=None, description="SKU信息"
)
clear_from_ws: bool = Field(True, description="是否清空抓取工作空间")
clear_to_ws: bool = Field(True, description="是否清空放置工作空间")
@validator("from_options", "to_options", pre=True)
def validate_options(cls, v):
if isinstance(v, str):
return [v]
elif isinstance(v, list):
return v
raise ValueError(_("'from_options' 和 'to_options' 必须为字符串或字符串列表."))
@validator("target_num")
def validate_target_num(cls, num: int) -> int:
"""验证target_num是否有效.
Args:
num: 任务数量.
Returns:
int: 任务数量.
"""
if num == 0:
raise ValueError("'target_num' 不能为0.")
if num < -1:
raise ValueError("'target_num' 不能小于-1.")
return num
@validator("sku_info")
def validate_sku_info(
cls, sku: Optional[SKUInfoInputSchema], values: dict
) -> Optional[SKUInfoInputSchema]:
"""验证sku_info是否有效."""
_type = values.get("task_type", None)
if (
_type == enums.TaskType.SINGLE_DEPAL
or _type == enums.TaskType.SINGLE_PAL
):
if sku is None:
raise ValueError(_("单拆或单码任务 'sku_info' 不能为空."))
if sku is not None:
if values.get("target_num"):
target_num = values.get("target_num")
elif values.get("target_num", None) is None:
target_num = sku.sku_num
elif sku.sku_num is not None:
target_num = sku.sku_num
else:
raise ValueError(_("'target_num' 和 'sku_info.sku_num' 不能同时为空."))
assert target_num is not None, "target_num 不能为 None"
if target_num == 0:
raise ValueError("'target_num' 不能为0.")
if target_num < -1:
raise ValueError("'target_num' 不能小于-1.")
values["target_num"] = target_num
return sku
class Config:
validate_assignment = True
class SingleCreateSchema(TaskCreateSchema):
sku_info: SKUInfoInputSchema = Field(description="SKU信息")
class SingleDepalletizeCreateSchema(SingleCreateSchema):
"""用于创建单拆任务的Schema"""
task_type: Final[enums.TaskType] = Field(
enums.TaskType.SINGLE_DEPAL, description="任务类型", const=True
)
class Config:
schema_extra = {
"example": {
"task_id": "3",
"sku_info": {
"sku_id": "",
"length": 1000,
"width": 1000,
"height": 1000,
"weight": 5,
"sku_num": 5,
},
"from": "1",
"to": "2",
"clear_from_ws": True,
"clear_to_ws": True,
}
}
class SinglePalletizeCreateSchema(SingleCreateSchema):
"""用于创建单拆任务的Schema"""
task_type: Final[enums.TaskType] = Field(
enums.TaskType.SINGLE_PAL, description="任务类型", const=True
)
class Config:
schema_extra = {
"example": {
"task_id": "3",
"sku_info": {
"sku_id": "",
"length": 1000,
"width": 1000,
"height": 1000,
"weight": 5,
"sku_num": 5,
},
"from": "1",
"to": "2",
"clear_from_ws": True,
"clear_to_ws": True,
}
}
class OrderItem(PreTask):
"""订单项模型."""
order_id: Optional[str] = Field(default=None, description="订单ID")
task_type: enums.TaskType = Field(..., description="任务类型")
target_num: Optional[int] = Field(default=None, description="任务数量")
from_options: List[str] = Field(
default_factory=list,
description="可使用的抓取位",
alias="from",
)
to_options: List[str] = Field(
default_factory=list,
description="可使用的放置位",
alias="to",
)
sku_info: Optional[SKUInfoInputSchema] = Field(
default=None, description="SKU信息"
)
sku_infos: List[SKUInfoInputSchema] = Field(
default_factory=list, description="SKU信息列表"
)
class OrderCreateSchema(BaseModel):
"""订单创建模型."""
# 公共字段 start
order_id: str = Field(
default_factory=lambda: str(uuid.uuid4()),
title="订单ID",
description="允许为空，为空时自动生成",
)
order_type: enums.OrderType = Field(
title="订单类型",
description="订单类型",
)
order_items: List[OrderItem] = Field(
default_factory=list,
title="预处理任务列表",
description="预处理任务列表, 用于规划",
alias="order_items",
)
customized_data: dict = Field(
default_factory=dict,
title="自定义数据",
description="自定义数据",
)
# 公共字段 end
# 控序混码字段 start
global_barcode_direction: int = Field(default=-1, title="全局条码方向")
time_budget: int = Field(
default=-1,
title="最大规划时间",
description="最大规划时间，单位：秒, -1 表示不限制, 直到规划完成",
)
place_pallet_budget: int = Field(
default=-1,
title="最多放置托盘数",
description="最多放置托盘数, -1 表示不限制",
)
supply_pallet_budget: int = Field(
default=-1,
title="最多来料托盘数",
description="最多来料托盘数, -1 表示不限制",
)
fix_order: bool = Field(
default=False,
title="是否修正顺序",
description="仅 supply_pallet_budget > 0 时有效",
)
# RockyDual 相关字段
license_plate_number: Optional[str] = Field(
default=None,
title="车牌号",
description="车牌号",
)
truck_inner_dimension: Optional[dict] = Field(
default=None,
title="车厢尺寸(m)",
description="车厢尺寸(m)",
)
@validator("order_items", pre=True, each_item=True)
def fill_value(cls, v, values):
# 填充任务类型
v["task_type"] = enums.TaskType(values["order_type"].value)
v["order_id"] = values["order_id"]
if values["order_type"] == enums.OrderType.CONTROLLED_SEQ_MCP:
if len(v["from"]) != 1:
raise ValueError(
_("控序混码的 'from' 可选数量仅能为1, 当前为: {v}").format(v=v)
)
if len(v["to"]) <= 0:
raise ValueError(
_("控序混码的 'to' 可选数量必须大于0, 当前为: {v}").format(v=v)
)
return v
@validator("order_items")
def validate_order_items(
cls, order_items: List[OrderItem], values: dict
) -> List[OrderItem]:
_type = values.get("task_type", None)
if (
_type == enums.OrderType.SINGLE_DEPAL
or _type == enums.OrderType.SINGLE_PAL
):
if not order_items:
raise ValueError(_("单拆或单码订单 'order_items' 不能为空."))
return order_items
@validator("fix_order")
def validate_fix_order(cls, fix_order: bool, values: dict) -> bool:
"""验证fix_order是否有效."""
if fix_order is False:
return fix_order
supply_pallet_budget = values.get("supply_pallet_budget", None)
if supply_pallet_budget is None:
raise ValueError(_("'fix_order' 仅在 'supply_pallet_budget' 不为空时有效."))
if supply_pallet_budget <= 0:
raise ValueError(_("'fix_order' 仅在 'supply_pallet_budget' 大于0时有效."))
elif supply_pallet_budget == 1:
return fix_order
items: List[OrderItem] = values.get("order_items", [])
# 按 supply_pallet_budget 进行分组，组内的 item.from[0] 不能相同
for i in range(0, len(items), supply_pallet_budget):
_from = set()
_items = items[i : i + supply_pallet_budget]
for item in _items:
_from.add(item.from_options[0])
if len(_from) != supply_pallet_budget:
raise ValueError(
_("未通过验证，同一组内的来料位不能相同, 当前为: {v}").format(v=_items)
)
return fix_order
class Config:
allow_population_by_field_name = True
schema_extra = {
"example": {
"order_id": "string",
"order_type": 4,
"global_barcode_direction": -1,
"time_budget": -1,
"place_pallet_budget": -1,
"supply_pallet_budget": -1,
"fix_order": False,
"order_items": [
{
"from": ["0"],
"to": ["1"],
"target_num": 1,
"sku_info": {
"id": "string",
"type": "box",
"length": 500,
"width": 400,
"height": 300,
"weight": 1,
"weight_unit": "kg",
"length_unit": "mm",
"barcode_direction": 0,
"load_bearing": -1,
"direction_options": ["Ori", "RotZ"],
},
}
],
}
}
class OrderArriveSchema(BaseModel):
order_id: str = Field(..., title="订单ID")
sku_info: SKUInfoInputSchema = Field(..., title="SKU信息")
from_ws: str = Field(..., title="来源", alias="from")
to_ws: str = Field(..., title="目标", alias="to")
class Config:
allow_population_by_field_name = True
schema_extra = {
"example": {
"order_id": "string",
"sku_info": {
"id": "string",
"type": "box",
"length": 0.5,
"width": 0.4,
"height": 0.3,
"weight": 1,
"weight_unit": "kg",
"length_unit": "m",
"barcode_direction": 0,
"load_bearing": -1,
"direction_options": ["Ori", "RotZ"],
},
"from": "string",
"to": "string",
}
}
class OrderBatchArriveSchema(BaseModel):
order_id: str = Field(..., title="订单ID")
batch_id: str = Field(..., title="批次ID")
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\schemas\__init__.py | from .max_schemas import (
ErrorDetailSchema,
OrderInfoOutputSchema,
OrderSKUListOutputSchema,
ReportErrorInputSchema,
ReportPlanningResultInputSchema,
ReportTaskEndingInputSchema,
ReportTaskStatusInputSchema,
ReportTaskStatusInputV2Schema,
ReportTaskStatusOutputSchema,
SKUInfoOutputSchema,
TaskInfoOutputSchema,
WorkspaceOutputSchema,
WorkspaceUpdateSchema,
)
from .wcs_schemas import (
OrderArriveSchema,
OrderBatchArriveSchema,
OrderCreateSchema,
SingleCreateSchema,
SingleDepalletizeCreateSchema,
SinglePalletizeCreateSchema,
SKUInfoInputSchema,
TaskCreateSchema,
)
__all__ = [
"TaskInfoOutputSchema",
"WorkspaceOutputSchema",
"WorkspaceUpdateSchema",
"ReportTaskStatusInputSchema",
"ReportTaskStatusInputV2Schema",
"ReportTaskStatusOutputSchema",
"ReportTaskEndingInputSchema",
"ReportErrorInputSchema",
"ReportPlanningResultInputSchema",
"TaskCreateSchema",
"SingleDepalletizeCreateSchema",
"SinglePalletizeCreateSchema",
"SingleCreateSchema",
"OrderCreateSchema",
"ErrorDetailSchema",
"OrderInfoOutputSchema",
"OrderSKUListOutputSchema",
"OrderArriveSchema",
"OrderBatchArriveSchema",
"SKUInfoInputSchema",
"SKUInfoOutputSchema",
]
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\base.py | """工作流模块."""
from typing import Any, Literal, Optional, Tuple, TypeVar, Union
from fastapi.encoders import jsonable_encoder
from loguru import logger
from wcs_adaptor.schemas.max_schemas import (
OrderInfoOutputSchema,
ReportErrorInputSchema,
ReportTaskEndingInputSchema,
WorkspaceUpdateSchema,
)
from xyz_max_hmi_server import _, g, plc_manager, system_status
from xyz_max_hmi_server.entity.order import LiteOrder, Order
from xyz_max_hmi_server.entity.task import LiteTask as Task
from xyz_max_hmi_server.entity.workspace import Workspace
from xyz_max_hmi_server.exceptions import MAXException, XYZNotFoundError
from xyz_max_hmi_server.modules.error_map import ErrorMessage
from xyz_max_hmi_server.modules.error_records import record_vp_error
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.modules.manager.workspace_manager import (
WorkspaceManager,
)
from xyz_max_hmi_server.modules.message_pusher.push import MessagePusher
from xyz_max_hmi_server.modules.workflow.workflow import (
Workflow as BaseWorkflow,
)
from xyz_max_hmi_server.utils.request import request_by_http
T_Order = TypeVar("T_Order", bound=Order)
class Workflow(BaseWorkflow):
"""基础工作流
其他工作流都继承该类，如果一些方法不适用于某些工作流，可以重写该方法.
"""
mp: MessagePusher
order_manager: OrderManager[LiteOrder[Task]]
task_manager: TaskManager[Task]
workspace_manager: WorkspaceManager[Workspace]
# 健康检查接口(心跳接口，用于检查 WCS 是否在线)
api_health_check = "/api/health_check"
# 通知工作空间状态接口
api_report_ws_status = "/api/workspace_status"
# 上报异常信息接口
api_report_exception = "/api/exception"
# 上报单次节拍执行结果接口
api_report_one_cycle_result = "/api/cycle_result"
# 上报任务状态接口
api_report_task_status = "/api/order_step_result"
# 上报订单状态接口
api_report_order_status = "/api/order_result"
def __init__(self) -> None: # noqa: D107
self.order_manager = OrderManager()
self.task_manager = TaskManager()
self.workspace_manager = WorkspaceManager()
self.mp = MessagePusher()
self.g = g
def wcs_workspace_ready(self, ws_id: str):
"""工作空间到位"""
ws = self.workspace_manager.create_or_modify(ws_id, is_ready=True)
pallet = ws.get_current_pallet()
if pallet and (pallet.is_empty() or pallet.is_full()):
# 删除空拖盘或满拖盘
ws.remove_invalid_pallets()
old_pallet_id = pallet.pallet_id
# 表示更换拖盘
ws.use_next_pallet()
logger.info(
_("工作空间 '{0}' 更换拖盘 '{1}' -> '{2}'").format(
ws_id, old_pallet_id, ws.current_pallet_id
)
)
self.mp.order.info(_("工作空间 '{0}' 已就绪").format(ws_id))
return self.make_response()
def wcs_abort_order(self, order: LiteOrder):
"""WCS 中止订单"""
order.terminate()
return self.make_response()
def max_complete_order(self, order: LiteOrder):
"""完成订单
终止该订单下所有未完成的任务
"""
tasks = self.task_manager.get_tasks_by_order_id(order.order_id)
for task in tasks:
task.terminate(error="提前完成")
order.finish(auto_complete=True)
self.callback_order_finish(order)
return self.make_response()
def max_get_task_info(self):
"""获取当前任务信息."""
from xyz_max_hmi_server.templates.dpt.wcs_adaptor.schemas import (
SKUInfoOutputSchema,
TaskInfoOutputSchema,
)
task = self.task_manager.first()
if task is None:
return TaskInfoOutputSchema() # type: ignore
if task.is_pending():
# HACK: 调用任务开始方法
# 如果该任务存在订单，则将自动调用订单开始方法，表示该订单开始执行
task.start()
return TaskInfoOutputSchema(
result=True,
task_id=task.task_id,
task_status=task.task_status,
task_type=task.task_type,
from_ws=task.from_ws,
to_ws=task.to_ws,
sku_info=task.sku_info
and SKUInfoOutputSchema.parse_obj(task.sku_info),
target_num=task.target_num,
done_num=task.done_num,
undone_num=task.target_num - task.done_num,
customized_data=task.customized_data,
)
def max_get_order_info(self):
"""获取当前订单信息."""
order = self.order_manager.first()
if order is None:
return OrderInfoOutputSchema() # type: ignore
result = OrderInfoOutputSchema.parse_obj(order)
result.tasks = order.tasks # type: ignore
return result
def max_get_next_task(self):
"""获取下一个待执行的任务."""
from xyz_max_hmi_server.templates.dpt.wcs_adaptor.schemas import (
SKUInfoOutputSchema,
TaskInfoOutputSchema,
)
try:
task = self.task_manager[1]
except XYZNotFoundError:
return TaskInfoOutputSchema()
return TaskInfoOutputSchema(
result=True,
task_id=task.task_id,
task_type=task.task_type,
from_ws=task.from_ws,
to_ws=task.to_ws,
sku_info=SKUInfoOutputSchema.parse_obj(task.sku_info),
target_num=task.target_num,
done_num=task.done_num,
undone_num=task.target_num - task.done_num,
customized_data=task.customized_data,
)
def max_get_order_sku_list(self, order_id: str):
"""获取订单的 SKU 列表."""
order = self.order_manager.get_order_or_404(order_id)
pre_tasks = order.pre_tasks
skus = []
exists = set()
def _add_sku(sku):
if sku is None:
return
unique = (sku.length, sku.width, sku.height, sku.weight)
if unique in exists:
return
skus.append(sku)
exists.add(unique)
for pre_task in pre_tasks:
_add_sku(pre_task.sku_info)
for task in order.tasks:
_add_sku(task.sku_info)
return {"order_id": order_id, "skus": skus}
def max_get_workspace(self, ws_id: str):
"""获取工作空间信息."""
return self.workspace_manager.get_workspace_or_404(ws_id)
def max_update_workspace(self, body: WorkspaceUpdateSchema):
"""更新工作空间信息."""
func = (
self.handle_workspace_is_empty
if body.status == "empty"
else self.handle_workspace_is_full
)
for ws_id in body.ws_ids:
ws = self.workspace_manager.get_workspace_or_404(ws_id)
func(ws)
return {}
def max_report_task_ending(self, body: ReportTaskEndingInputSchema):
"""回报任务结束."""
tasks = []
order = None
def _handle_ending(task_id: str):
nonlocal order
task = self.task_manager.get_task_or_404(task_id)
if not (task.is_finished() or task.is_terminated()):
# 任务状态未完成
raise MAXException(
error_message=_("任务({0})未完成, 请勿调用").format(task_id)
).disable_msg_event()
# PERF: 因为回调函数可能超时并重试，这就意味当前 Sqlite 事务一直被占用, 所以这可能导致死锁
# 待事务提交之后，再调用回调函数
tasks.append(task)
# 设置任务状态为已结束
task.end()
if task.order_id is None:
return
order = self.order_manager.get_order_or_404(task.order_id)
if order.is_finished():
# 设置订单已结束
order.end()
else:
logger.warning(
"订单({})暂未完成，当前状态：{}, 当前进度 {}/{}".format(
order.order_id,
order.order_status,
order.completed_boxes_count,
order.total_boxes_count,
)
)
for task_id in body.task_ids:
_handle_ending(task_id)
if order:
self.callback_order_finish(order)
return {}
def max_report_error(self, body: ReportErrorInputSchema):
"""VP 回报错误."""
error = ErrorMessage(
code=body.error_code, msg=body.error_msg, tip=body.tip
)
task = (
self.task_manager.get_task_by_id(body.task_id)
if body.task_id
else None
)
# 设置系统状态为异常
system_status.set_error()
# 在订单日志中展示错误
self.mp.order.error(error.msg)
# 记录异常至数据库
record_vp_error(error=error, task=task)
try:
# PLC 红灯亮起
plc_manager.light.set(red=1, yellow=0, green=0)
except Exception as e:
logger.error("PLC 红灯亮起失败: {}", e)
# 上报错误
self.callback_exception(error=error, task=task)
return {}
def handle_workspace_is_full(self, ws: Workspace):
"""处理工作空间已满."""
self.mp.order.info(_("码垛位 '{0}' 已满").format(ws.ws_id))
ws.not_ready()
self.callback_workspace_change(ws.ws_id, "to", "full")
def handle_workspace_is_empty(self, ws: Workspace):
"""处理工作空间已空."""
self.mp.order.info(_("拆垛位 '{0}' 已空").format(ws.ws_id))
ws.not_ready()
self.callback_workspace_change(ws.ws_id, "from", "empty")
def make_response(
self,
data: Any = None,
code: int = 0,
msg: str = "success",
):
"""统一构建返回给 WCS 上游的响应结构"""
if data is None:
data = {}
# NOTE: 根据协定的响应格式返回数据
return {"code": code, "msg": msg, "data": data}
def callback_one_cycle_finish(self, task: Task, pick_num: int):
"""调用回报一次抓放结果的回调接口."""
order = task.order
if order is None:
data = {"task_id": task.task_id, "pick_num": pick_num}
else:
data = {
"order_id": task.order_id,
"pick_num": pick_num,
"step_num": pick_num,
"done_num": order.completed_boxes_count, # 该订单下已抓放的数量
"total_num": order.total_boxes_count,
"sku_info": jsonable_encoder(task.sku_info),
}
request_by_http(self.api_report_one_cycle_result, data)
self.mp.order.info(_("完成一次抓放，抓放数量：{0}").format(pick_num))
def callback_task_finish(self, task: Task):
"""调用回报任务完成的回调接口."""
order = task.order
if order:
data = {
"order_id": order.order_id,
"step_num": 1,
"done_num": task.done_num,
"total_num": task.target_num,
"sku_info": jsonable_encoder(task.sku_info),
}
request_by_http(self.api_report_task_status, data)
self.mp.order.info(_("订单 '{0}' 当前步骤已完成").format(order.order_id))
else:
data = {
"task_id": task.task_id,
"task_status": 0,
"pick_num": task.done_num,
"target_num": task.target_num,
"message": task.task_status.name,
"customized_result": {},
}
request_by_http(self.api_report_task_status, data)
self.mp.order.info(_("任务 '{0}' 已完成").format(task.task_id))
def callback_order_finish(self, order: LiteOrder[Any]):
"""调用回报订单完成的回调接口."""
data = {
"order_id": order.order_id,
"done_num": order.completed_boxes_count,
"total_num": order.total_boxes_count,
}
request_by_http(self.api_report_order_status, data)
self.mp.order.info(
_("订单 '{0}' 已完成, 任务完成数: {1}").format(
order.order_id, order.total_num
)
)
def callback_exception(
self, error: ErrorMessage, task: Optional[Task] = None
):
"""调用回报异常信息的回调接口."""
# NOTE: 根据实际业务需求，更改上报的异常信息
data = {
"error_code": error.code,
"error_msg": error.msg,
}
resp = request_by_http(self.api_report_exception, data)
self.mp.order.info(_("回报异常信息: {0}").format(error))
return resp
def callback_workspace_change(
self,
ws_id: str,
ws_type: Literal["from", "to"],
status: Literal["full", "empty"],
):
"""调用回报工作空间状态的回调接口.
Args:
ws_id: 工作空间ID
ws_type: 工作空间类型
status: 工作空间状态
"""
data = {
"id": ws_id,
"type": ws_type,
"status": status,
}
request_by_http(self.api_report_ws_status, data)
msg = _("已通知上游工作空间状态： {0} '{1}' 已{2}").format(
_("抓取位") if ws_type == "from" else _("放置位"),
ws_id,
_("满") if status == "full" else _("空"),
)
self.mp.order.info(msg)
def callback_health_check(self) -> bool:
"""调用回报健康检查的回调接口."""
resp = request_by_http(
self.api_health_check, until_success=False, retry=0
)
return bool(resp and resp.status_code == 200)
def send_request_to_wcs(
self,
api: str,
data: dict,
scheme: Literal["http", "https"] = "http",
method: Literal["GET", "POST"] = "POST",
timeout: Union[float, Tuple[float, float]] = (0.5, 0.5),
until_success: bool = False,
retry: int = 3,
retry_interval: float = 0.2,
url: Optional[str] = None,
):
"""向 WCS 发送请求."""
return request_by_http(
api,
data,
scheme=scheme,
method=method,
timeout=timeout,
until_success=until_success,
retry=retry,
retry_interval=retry_interval,
url=url,
)
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\cmcp_workflow.py | """控序混码(输送线来料)工作流."""
import collections
import uuid
from typing import TYPE_CHECKING, Dict, List, Literal, Union
from fastapi import BackgroundTasks
from fastapi.encoders import jsonable_encoder
from loguru import logger
from wcs_adaptor.schemas.max_schemas import (
OrderInfoOutputSchema,
ReportPlanningResultInputSchema,
ReportTaskEndingInputSchema,
ReportTaskStatusInputSchema,
ReportTaskStatusInputV2Schema,
)
from wcs_adaptor.schemas.wcs_schemas import OrderArriveSchema, OrderCreateSchema
from xyz_max_hmi_server import _, crud, enums, services
from xyz_max_hmi_server.entity.order import CMCPOrder, RMCPOrder
from xyz_max_hmi_server.entity.pallet import Pallet
from xyz_max_hmi_server.entity.sku import SKUInfo
from xyz_max_hmi_server.entity.workspace import Workspace
from xyz_max_hmi_server.exceptions import (
MAXException,
WCSException,
XYZNotFoundError,
XYZOrderError,
XYZValidationError,
)
from xyz_max_hmi_server.schemas.arrival_sequence import BoxDimension
from xyz_max_hmi_server.schemas.base import _list
from xyz_max_hmi_server.schemas.cmcp_planning_result import (
CMCPPlanningResultCreateSchema,
CMCPPlanningResultUpdateSchema,
)
from xyz_max_hmi_server.utils.request import request_by_http
from .base import Workflow
if TYPE_CHECKING:
from wcs_adaptor.entity.task import CMCPTask, RMCPTask
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.modules.manager.workspace_manager import (
WorkspaceManager,
)
class CMCPWorkflow(Workflow):
"""控序混码(输送线来料)工作流."""
order_manager: "OrderManager[Union[CMCPOrder[CMCPTask], RMCPOrder[RMCPTask]]]"
task_manager: "TaskManager[Union[CMCPTask, RMCPTask]]"
workspace_manager: "WorkspaceManager[Workspace]"
# 向上游上报规划结果的 api
api_report_planning_result = "/api/planning_result"
# 向上游上报来料顺序错误的 api
api_report_arrival_sequence_error = "/api/arrival_sequence_error"
# 是否在当前任务完成时，自动将下一个任务就绪
auto_ready_next_task: bool = False
# 视觉拍照校验是否开启, 视觉提前，用于提前校验箱子的尺寸
is_vision_check_enabled: bool = False
def __init__(self) -> None: # noqa: D107
super().__init__()
self.arrival_sequence_service = services.arrival_sequence
def wcs_create_order(
self, body: OrderCreateSchema, bg_tasks: BackgroundTasks
):
"""WCS 创建订单"""
from wcs_adaptor import mock
if self.order_manager.is_exists_by_order_id(body.order_id):
raise XYZOrderError(
order_id=body.order_id,
error_message=_("订单 '{0}' 已存在，不允许重复创建, 如需重新创建，请先中止该订单").format(
body.order_id
),
)
# NOTE: 由于混码服务器同一时间只能处理一个订单(控序或无序)
# 所以，需要判断是否存在正在进行中的无序混码订单
order = self.order_manager.first()
if (
order
and order.is_started()
and order.order_type == enums.OrderType.RANDOM_SEQ_MCP
):
raise WCSException(error_message=_("当前存在正在进行中的无序混码订单，无法创建新的控序混码订单"))
planning_result_key = str(uuid.uuid4())
# 创建规划结果记录
create = CMCPPlanningResultCreateSchema(
order_id=body.order_id, key=planning_result_key
)
crud.cmcp_planning_result.create(obj_in=create)
# 创建订单
order_dict = jsonable_encoder(body)
order_dict["planning_result_key"] = planning_result_key
order = CMCPOrder.parse_obj(order_dict)
self.order_manager.append(order)
self.mp.order.info(_("已收到控序混码订单 '{0}'").format(body.order_id))
bg_tasks.add_task(mock.mock_report_planning_result, order)
return self.make_response(data={"order_id": order.order_id})
def wcs_abort_order(self, order: CMCPOrder):
"""中止订单."""
# TODO: 如果规划已完成，则不需要更新规划结果
crud.cmcp_planning_result.set_error_by_key(
key=order.planning_result_key,
error_msg=_("订单被中止"),
)
return super().wcs_abort_order(order)
def wcs_order_arrived(
self, body: OrderArriveSchema, bg_tasks: BackgroundTasks
):
"""WCS 通知物料已到位."""
from wcs_adaptor import mock
order = self.order_manager.get_order_or_404(body.order_id)
task = self.task_manager.first_received_by_order_id(order.order_id)
if task is None:
raise XYZValidationError(_("当前订单没有可执行的任务"))
if task.task_type != enums.TaskType.CONTROLLED_SEQ_MCP:
raise XYZValidationError(_("当前任务不是控序任务"))
if task.order_id != order.order_id:
raise XYZValidationError(_("当前任务不属于该订单"))
if task.sku_info != body.sku_info:
logger.warning(
f"物料信息不匹配, 任务物料信息: {task.sku_info}, 实际物料信息:" f" {body.sku_info}"
)
raise XYZValidationError(_("物料信息不匹配"))
if self.is_vision_check_enabled:
seqs = self.arrival_sequence_service.list_checked_and_uncomplete(
order_id=order.order_id
)
task_ids = {seq.extra["task_id"] for seq in seqs}
if task.task_id not in task_ids:
raise XYZValidationError(_("箱子还未检测，不允许请求物料已到位"))
task.from_ws = body.from_ws
task.to_ws = body.to_ws
task.ready()
from_ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
if from_ws.is_ready is False:
raise WCSException(
_("抓取工作空间 '{0}' 未就绪，请先确保工作空间就绪").format(task.from_ws)
)
to_ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
if to_ws.is_ready is False:
raise WCSException(
_("放置工作空间 '{0}' 未就绪，请先确保工作空间就绪").format(task.to_ws)
)
self.mp.order.info(
_("订单 '{0}' 的物料已到位, 物料信息：{1}").format(order.order_id, body.sku_info)
)
bg_tasks.add_task(mock.mock_report_order_finish, task=task)
return self.make_response()
def max_get_task_info(self):
"""获取当前任务信息."""
from xyz_max_hmi_server.templates.dpt.wcs_adaptor.schemas import (
SKUInfoOutputSchema,
TaskInfoOutputSchema,
)
task = self.task_manager.first()
# 仅返回控序混码任务
if task is None or task.task_type != enums.TaskType.CONTROLLED_SEQ_MCP:
return TaskInfoOutputSchema() # type: ignore
if task.is_pending():
# HACK: 调用任务开始方法
# 如果该任务存在订单，则将自动调用订单开始方法，表示该订单开始执行
task.start()
return TaskInfoOutputSchema(
result=True,
task_id=task.task_id,
task_status=task.task_status,
task_type=task.task_type,
from_ws=task.from_ws,
to_ws=task.to_ws,
sku_info=task.sku_info
and SKUInfoOutputSchema.parse_obj(task.sku_info),
target_num=task.target_num,
done_num=task.done_num,
undone_num=task.target_num - task.done_num,
customized_data=task.customized_data,
)
def max_get_unplanned_order(self):
"""获取未做混码规划的订单."""
order = self.order_manager.first_unplanned()
if order is None:
return OrderInfoOutputSchema() # type: ignore
if (
not isinstance(order, CMCPOrder)
or order.order_type != enums.OrderType.CONTROLLED_SEQ_MCP
):
raise XYZValidationError(_("当前订单不是控序混码订单"))
# HACK: 默认请求该接口时，就意味着开始规划
if order.is_pending():
order.start_planning()
result = OrderInfoOutputSchema.parse_obj(order)
result.tasks = order.tasks
result.planning_result_key = order.planning_result_key
result.fix_order = order.fix_order
self.mp.order.info(_("订单 '{0}' 规划进行中").format(order.order_id))
return result
def max_report_planning_result(self, body: ReportPlanningResultInputSchema):
"""VP 上报规划结果."""
# 托盘索引与可放置的物料数量的映射
placeable_count_by_pallet_idx = collections.defaultdict(int)
# 抓取工作空间与工作空间编号的映射
from_ws_map_by_ws_id: Dict[str, Workspace] = {}
# 放置工作空间与工作空间编号的映射
to_ws_map_by_ws_id: Dict[str, Workspace] = {}
# pallet_idx 与 工作空间编号的映射
pallet_idx_map_by_ws_id: Dict[int, Workspace] = {}
def _validate_order_for_planning_report():
if (
order.order_type != enums.OrderType.CONTROLLED_SEQ_MCP
or not isinstance(order, CMCPOrder)
):
raise MAXException(
error_message=_("订单 {0} 不是控序混码订单").format(body.order_id)
).disable_msg_event()
if order.planning_result_key != body.planning_result_key:
raise MAXException(
error_message=_("订单 {0} 规划结果 key 不匹配").format(body.order_id)
).disable_msg_event()
if order.has_success_planning_result():
raise MAXException(
error_message=_("订单 {0} 已存在规划结果").format(body.order_id)
).disable_msg_event()
def _update_order_status_and_planning_result(planning_result):
order.end_planning()
# 更新规划结果
if body.status is True and body.results:
update = CMCPPlanningResultUpdateSchema(
results=body.results,
status=enums.CMCPPlanningStatus.SUCCESS,
)
else:
update = CMCPPlanningResultUpdateSchema(
error_msg=body.error_msg,
status=enums.CMCPPlanningStatus.FAILURE,
)
update.start_time = body.start_time
update.end_time = body.end_time
crud.cmcp_planning_result.update(
db_obj=planning_result, obj_in=update
)
def _create_tasks_and_update_workspaces():
from wcs_adaptor.entity.task import CMCPTask
for result in body.results:
task = CMCPTask(
task_id=str(uuid.uuid4()),
task_type=enums.TaskType.CONTROLLED_SEQ_MCP,
order_id=body.order_id,
sku_info=result.sku_info,
target_num=1,
customized_data=result.customized_data,
from_ws=result.from_ws,
to_ws=result.to_ws,
pallet_idx=result.pallet_idx,
serial_num=result.serial_num,
)
task.customized_data = {
"from_ws": result.from_ws,
"to_ws": result.to_ws,
**result.customized_data,
}
# 加入来料顺序表中
sku_info = result.sku_info.to_m()
sequence_id = self.arrival_sequence_service.add_expect_box_size(
order_id=body.order_id,
box_size={
"length": sku_info.length,
"width": sku_info.width,
"height": sku_info.height,
},
extra={
"task_id": task.task_id,
"serial_num": result.serial_num,
"pallet_idx": result.pallet_idx,
"from_ws": result.from_ws,
"to_ws": result.to_ws,
"customized_data": task.customized_data,
},
)
task.customized_data["sequence_id"] = sequence_id
# 将任务加入到任务管理器中，但此时 VP 还无法从任务管理器中获取到任务
# 因为此时任务都是未就绪的
self.task_manager.receive(task)
if result.from_ws not in from_ws_map_by_ws_id:
ws = self.workspace_manager.create_or_modify(
result.from_ws, False
)
from_ws_map_by_ws_id[result.from_ws] = ws
if result.to_ws not in to_ws_map_by_ws_id:
ws = self.workspace_manager.create_or_modify(
result.to_ws, False
)
to_ws_map_by_ws_id[result.to_ws] = ws
placeable_count_by_pallet_idx[result.pallet_idx] += 1
pallet_idx_map_by_ws_id[result.pallet_idx] = to_ws_map_by_ws_id[
result.to_ws
]
def _create_pallets():
for pallet_idx, count in placeable_count_by_pallet_idx.items():
ws = pallet_idx_map_by_ws_id[pallet_idx]
pallet = Pallet(
pallet_id=str(pallet_idx) + "_" + str(uuid.uuid4())[0:8],
workspace_id=ws.ws_id,
pickable_quantity=-1,
placeable_quantity=count,
)
ws.add_pallet(pallet)
if ws.current_pallet_id is None:
ws.pallet_in(pallet)
logger.info(
f"工作空间 '{ws.ws_id}' 已加入托盘 '{pallet.pallet_id}',"
f" Pallet: {pallet}"
)
def _get_planning_result():
_planning_result = (
crud.cmcp_planning_result.get_by_order_id_and_key(
order_id=body.order_id,
key=body.planning_result_key,
)
)
if _planning_result is None:
raise MAXException(
error_message=_("订单 {0} 不存在规划记录").format(body.order_id)
).disable_msg_event()
return _planning_result
order = self.order_manager.get_order_or_404(body.order_id)
if not isinstance(order, CMCPOrder):
raise MAXException(
error_message=f"订单 {body.order_id} 不是控序混码订单"
).disable_msg_event()
_validate_order_for_planning_report()
planning_result = _get_planning_result()
_update_order_status_and_planning_result(planning_result)
_create_tasks_and_update_workspaces()
_create_pallets()
# 向上游上报规划结果
self.callback_planning_result(order)
return {}
def callback_planning_result(self, order: CMCPOrder):
"""回报WCS控序混码订单规划完成"""
planning_result = order.get_planning_result()
if not planning_result:
raise MAXException(
_("订单 '{0}' 不存在规划结果").format(order.order_id)
).disable_msg_event()
status = False
results = []
if (
planning_result.status == enums.CMCPPlanningStatus.SUCCESS
and planning_result.results
):
status = True
for r in planning_result.results:
results.append(
{
"from": r.from_ws,
"to": r.to_ws,
"serial_num": r.serial_num,
"pallet_idx": r.pallet_idx,
"sku_info": jsonable_encoder(r.sku_info),
}
)
request_by_http(
self.api_report_planning_result,
{
"order_id": order.order_id,
"status": status,
"results": results,
"message": "success" if status else planning_result.error_msg,
},
)
if status:
self.mp.order.info(_("订单 '{0}' 规划成功").format(order.order_id))
else:
self.mp.order.error(
_("订单 '{0}' 规划失败，原因: {1}").format(
order.order_id, planning_result.error_msg
)
)
def max_report_task_status(self, body: ReportTaskStatusInputSchema):
"""回报任务状态."""
task = self.task_manager.get_task_or_404(body.task_id)
order = task.order
assert isinstance(order, CMCPOrder)
if task.is_finished():
raise MAXException(_("任务({0})已完成，不可重复回报").format(task.task_id))
# 设置托盘为非新托盘
self.workspace_manager.not_new_pallet(task.to_ws)
to_ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
pallet = to_ws.get_current_pallet()
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
if body.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
body.drop_num, body.pick_num
)
)
if body.pick_num > 0:
task.report_pick_num(
body.pick_num,
auto_remove=False,
auto_complete=False,
)
if pallet:
# 减少当前托盘的可放置数量
pallet.dec_placeable_quantity(body.pick_num)
self.callback_one_cycle_finish(task, body.pick_num)
if task.target_num == task.done_num:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
if pallet and pallet.is_full() or body.is_pal_pallet_full:
self.handle_workspace_is_full(to_ws)
# 拆垛盘空
if body.is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
self.handle_workspace_is_empty(ws)
if order is not None:
order.reload()
self.mp.order.info(
_("订单 '{0}' 已完成抓放：{1}/{2}").format(
order.order_id,
order.complete_num,
order.total_num,
)
)
return {
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
def max_report_task_status_v2(self, body: ReportTaskStatusInputV2Schema):
"""供 VP 做 pick 点回报"""
if body.action != enums.Action.PICKED:
raise MAXException(_("对于控序混码订单，该接口仅支持 pick"))
return _list([])
def max_get_next_task(self):
"""获取下一个任务, VP 用于异步视觉拍照校验."""
from xyz_max_hmi_server.templates.dpt.wcs_adaptor.schemas import (
SKUInfoOutputSchema,
TaskInfoOutputSchema,
)
default = TaskInfoOutputSchema()
first_task = self.task_manager.first()
if first_task is None:
return default
# 如果当前任务是放置托盘的最后一个任务，则不再获取下一个任务
ws = self.workspace_manager.get_workspace_or_404(first_task.to_ws)
pallet = ws.get_current_pallet()
if pallet and (
pallet.placeable_quantity == 1 or pallet.placeable_quantity == 0
):
return default
try:
task = self.task_manager[1]
except XYZNotFoundError:
return default
return TaskInfoOutputSchema(
result=True,
task_id=task.task_id,
task_type=task.task_type,
from_ws=task.from_ws,
to_ws=task.to_ws,
sku_info=SKUInfoOutputSchema.parse_obj(task.sku_info),
target_num=task.target_num,
done_num=task.done_num,
undone_num=task.target_num - task.done_num,
customized_data=task.customized_data,
)
def max_report_task_ending(self, body: ReportTaskEndingInputSchema):
"""供 VP 做任务结束回报"""
task_id = body.task_id
if not task_id:
raise MAXException(_("任务编号不能为空"))
task = self.task_manager.get_task_or_404(task_id)
order = self.order_manager.get_order_or_404(task.order_id)
if not (task.is_finished() or task.is_terminated()):
# 任务状态未完成
raise MAXException(
error_message=_("任务({0})未完成, 请勿调用").format(task_id)
).disable_msg_event()
if self.auto_ready_next_task:
next_task = task.next_task()
next_task.ready()
# 设置任务状态为已结束
task.end()
# 标记箱子已经完成
self.arrival_sequence_service.mark_as_complete(
task.customized_data["sequence_id"]
)
if order.is_finished():
# 设置订单已结束
order.end()
self.callback_order_finish(order)
else:
logger.warning(
"订单({})暂未完成，当前状态：{}, 当前进度 {}/{}".format(
order.order_id,
order.order_status,
order.completed_boxes_count,
order.total_boxes_count,
)
)
# NOTE: 当前任务是该订单的最后一个控序混码任务，且订单存在无序混码任务
# 则将该订单的类型修改为无序混码
if not order.has_cmcp_task() and order.is_converting_to_rmcp():
order = order.to_rmcp()
order.save()
self.mp.order.info(
_("最后一个控序混码任务已完成，控序混码订单 '{0}' 已转为无序混码订单").format(order.order_id)
)
logger.info(f"最后一个控序混码任务已完成，控序混码订单 '{order.order_id}' 已转为无序混码订单")
return {}
def max_get_first_unchecked(self):
"""获取当前未检测的箱子信息."""
record = self.arrival_sequence_service.first_unchecked()
if record is None:
return None
return {
"sequence_id": record.id,
"dimension": {
"width": record.expect_box_size["width"],
"height": record.expect_box_size["height"],
"length": record.expect_box_size["length"],
},
}
def max_report_check_result(
self,
sequence_id: int,
is_match: bool,
actual_box_size: BoxDimension,
):
"""上报检测结果.
检查当前订单是否已经转无序，或者正在转无序
如果是，则不需要再上报检测结果
且直接生成并追加无序混码任务
"""
from wcs_adaptor.entity.task import RMCPTask
order = self.order_manager.first()
if order is None:
raise MAXException(
error_message=_("当前不存在控序混码订单")
).disable_msg_event()
seq = self.arrival_sequence_service.get_by_sequence_id(
sequence_id=sequence_id
)
if seq is None:
raise XYZNotFoundError(f"Sequence id {sequence_id} is not found.")
if order.order_type == enums.OrderType.RANDOM_SEQ_MCP or (
order.order_type == enums.OrderType.CONTROLLED_SEQ_MCP
and order.is_converting_to_rmcp()
):
sku = SKUInfo(
sku_id="",
length=actual_box_size["length"],
width=actual_box_size["width"],
height=actual_box_size["height"],
weight=1,
length_unit="m",
weight_unit="kg",
)
task = RMCPTask.from_cmcp(
order_id=order.order_id,
sku_info=sku,
arrival_sequence=seq,
)
self.task_manager.receive(task) # type: ignore
elif is_match is False:
logger.info("视觉校验尺寸不匹配")
self.mp.order.info(
_("箱子尺寸不匹配，期望尺寸: {0}, 实际尺寸: {1}").format(
seq.expect_box_size, actual_box_size
)
)
self.send_request_to_wcs(
self.api_report_arrival_sequence_error,
data={
"error": -1,
"error_msg": "尺寸不匹配",
"is_match": is_match,
"actual_box_size": actual_box_size,
"expect_box_size": seq.expect_box_size,
},
)
self.arrival_sequence_service.update_match_result(
sequence_id=sequence_id,
is_match=is_match,
actual_box_size=actual_box_size,
)
self.arrival_sequence_service.mark_as_checked(sequence_id=sequence_id)
return {}
def wcs_cmcp2rmcp_is_convert(self, is_convert: bool):
"""WCS 设置是否转换控序混码为无序混码."""
self.g.set_persist("cmcp2rmcp_is_convert", is_convert)
if is_convert:
self.mp.order.info(_("上游决定尝试转换控序混码为无序混码"))
logger.info("上游决定尝试转换控序混码为无序混码")
else:
self.mp.order.info(_("上游决定不再尝试转换控序混码为无序混码"))
logger.info("上游决定不再尝试转换控序混码为无序混码")
return self.make_response()
def max_cmcp2rmcp_is_convert(self):
"""获取 WCS 是否转换控序混码为无序混码."""
return {"result": self.g.get("cmcp2rmcp_is_convert")}
def max_handle_cmcp2rmcp(
self,
handle_method: Literal[
"immediately",
"delayed",
"cancel",
],
):
"""处理控序混码转无序混码."""
order = self.order_manager.first()
if order is None:
raise MAXException(
error_message=_("当前不存在控序混码订单")
).disable_msg_event()
if isinstance(order, RMCPOrder) and order.is_from_cmcp():
return {}
if isinstance(order, CMCPOrder) and order.is_converting_to_rmcp():
return {}
if (
order.order_type != enums.OrderType.CONTROLLED_SEQ_MCP
or not isinstance(order, CMCPOrder)
):
raise MAXException(error_message="当前订单不是控序混码订单").disable_msg_event()
self.g.unset("cmcp2rmcp_is_convert")
# 添加无序混码任务
if handle_method == "cancel":
order.terminate(error=_("来料顺序错误，订单被中止"))
logger.info("来料顺序错误，订单被中止")
self.mp.order.error(_("来料顺序错误，订单被中止"))
return {}
tasks = order.get_tasks()
if not tasks:
raise MAXException(error_message=_("当前订单不存在任务")).disable_msg_event()
task_ids: List[str] = [t.task_id for t in tasks]
delete_tasks: List["CMCPTask"]
if handle_method == "immediately":
logger.info("立即转换控序混码为无序混码")
seq = self.arrival_sequence_service.first(
is_checked=True, is_completed=False
)
if seq is None:
raise MAXException(
error_message="当前不存在已检查且未完成的箱子"
).disable_msg_event()
task_id = seq.extra["task_id"]
current_task = self.task_manager.get_task_or_404(task_id=task_id)
idx = task_ids.index(task_id)
if current_task.is_started():
self.mp.order.info(_("转换策略: 等待本次抓放任务完成后将转为无序混码"))
idx += 1
else:
self.mp.order.info(_("转换策略: 立即转换控序混码为无序混码"))
remain_tasks = tasks[:idx]
delete_tasks = tasks[idx:]
elif handle_method == "delayed":
seq = self.arrival_sequence_service.last(is_checked=True)
if not seq:
raise MAXException(
error_message="当前不存在已检查的箱子"
).disable_msg_event()
self.mp.order.info(_("转换策略: 延迟转换控序混码为无序混码, 等待最后一个控序混码任务结束后再转无序混码"))
logger.info("延迟转换控序混码为无序混码")
# 删除 task_id 及之后的所有任务
seq = self.arrival_sequence_service.last_checked(order.order_id)
if seq is None:
idx = 0
else:
task_id = seq.extra["task_id"]
try:
idx = task_ids.index(task_id)
except ValueError as e:
raise MAXException(error_message=f"{task_id} 任务不存在") from e
remain_tasks = tasks[:idx]
delete_tasks = tasks[idx:]
else:
raise MAXException(
error_message=_("不支持的处理方式: {0}").format(handle_method)
).disable_msg_event()
# 移除所属订单的控序混码任务
self.task_manager.remove_by_order_id(
order.order_id, exclude=[t.task_id for t in remain_tasks]
)
delete_task_map = {task.task_id: task for task in delete_tasks}
seqs = self.arrival_sequence_service.list_checked_and_uncomplete(
order.order_id
)
if not seqs:
logger.warning(f"{order.order_id} 不存在已检查且未完成的箱子")
for seq in seqs:
task_id = seq.extra["task_id"]
if task_id not in delete_task_map:
continue
old_task = delete_task_map[task_id]
if seq.actual_box_size is None:
continue
new_task = old_task.to_rmcp()
new_task.sku_info = SKUInfo(
sku_id="",
length=seq.actual_box_size["length"],
width=seq.actual_box_size["width"],
height=seq.actual_box_size["height"],
weight=1,
length_unit="m",
weight_unit="kg",
)
self.task_manager.receive(new_task) # type: ignore
# 此时可能仍有部分控序混码任务
# 需要待这些任务执行完之后，才能完全转无序订单
# 所以，此处判断当前控序混码订单是否还有任务，如果没有则转换
# 否则，需要等待最后一个控序混码任务 ending 时，再转为无序混码订单
if not order.has_cmcp_task():
order = order.to_rmcp()
order.save()
self.mp.order.info(
_("控序混码订单 '{0}' 已转为无序混码订单").format(order.order_id)
)
logger.info(f"控序混码订单 '{order.order_id}' 已转为无序混码订单")
return {}
cmcp_workflow = CMCPWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\cmcp_workflow_pallet.py | """控序混码(托盘来料)工作流."""
import collections
import uuid
from typing import TYPE_CHECKING, Dict, OrderedDict, cast
from fastapi import BackgroundTasks
from loguru import logger
from wcs_adaptor.entity.task import CMCPTask
from wcs_adaptor.schemas.max_schemas import (
ReportPlanningResultInputSchema,
ReportTaskEndingInputSchema,
ReportTaskStatusInputSchema,
ReportTaskStatusInputV2Schema,
)
from wcs_adaptor.schemas.wcs_schemas import OrderBatchArriveSchema
from xyz_max_hmi_server import _, crud, enums
from xyz_max_hmi_server.entity.order import CMCPOrder
from xyz_max_hmi_server.entity.pallet import Pallet
from xyz_max_hmi_server.entity.workspace import Workspace
from xyz_max_hmi_server.exceptions import (
MAXException,
WCSException,
XYZNotFoundError,
XYZValidationError,
)
from xyz_max_hmi_server.schemas.base import _list
from xyz_max_hmi_server.schemas.cmcp_planning_result import (
CMCPPlanningResultUpdateSchema,
)
from .cmcp_workflow import CMCPWorkflow
if TYPE_CHECKING:
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.modules.manager.workspace_manager import (
WorkspaceManager,
)
class CMCPWorkflowPallet(CMCPWorkflow):
"""控序混码(托盘来料)工作流."""
order_manager: "OrderManager[CMCPOrder[CMCPTask]]"
task_manager: "TaskManager[CMCPTask]"
workspace_manager: "WorkspaceManager[Workspace]"
# 是否自动就绪下一个任务
auto_ready_next_task: bool = True
# 是否按批次来料
is_batch_arrived: bool = True
# 向上游通知批次（轮次）结束的 api
api_report_batch_finish = "/api/batch_result"
def wcs_order_batch_arrived(
self, body: OrderBatchArriveSchema, bg_tasks: BackgroundTasks
):
"""WCS 通知批次物料已到位.
将当前批次的第一个任务就绪，即 VP 可从任务队列中获取到该任务.
"""
order = self.order_manager.get_order_or_404(body.order_id)
task = self.task_manager.first_received_by_order_id(order.order_id)
if task is None:
raise XYZValidationError(_("当前订单没有可执行的任务"))
if task.task_type != enums.TaskType.CONTROLLED_SEQ_MCP:
raise XYZValidationError(_("当前任务不是控序任务"))
if task.batch_id != body.batch_id:
raise XYZValidationError(_("当前任务不属于该批次"))
from_ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
if from_ws.is_ready is False:
raise WCSException(
_("抓取工作空间 '{0}' 未就绪，请先确保工作空间就绪").format(task.from_ws)
)
to_ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
if to_ws.is_ready is False:
raise WCSException(
_("放置工作空间 '{0}' 未就绪，请先确保工作空间就绪").format(task.to_ws)
)
task.ready()
self.mp.order.info(
_("订单 '{0}' 的物料已到位, 物料信息：{1}").format(order.order_id, task.sku_info)
)
return self.make_response()
def max_report_planning_result(self, body: ReportPlanningResultInputSchema):
"""上报规划结果."""
order = self.order_manager.get_order_or_404(body.order_id)
if order.order_type != enums.OrderType.CONTROLLED_SEQ_MCP:
raise XYZValidationError(_("当前订单不是控序混码订单"))
# 设置订单状态为已规划
order.end_planning()
if not isinstance(order, CMCPOrder):
raise MAXException(
error_message=_("订单 {0} 不是控序混码订单").format(body.order_id)
).disable_msg_event()
if order.has_success_planning_result():
raise MAXException(
error_message=_("订单 {0} 已存在规划结果").format(body.order_id)
).disable_msg_event()
# 仅获取待定状态和正常进行中的规划记录
planning_result = crud.cmcp_planning_result.get_unplaned_by_order_id(
order_id=body.order_id
)
if not planning_result:
raise XYZNotFoundError(
_("订单 '{0}' 不存在进行中的规划").format(body.order_id)
)
order.end_planning()
# 更新规划结果
if body.status is True and body.results:
update = CMCPPlanningResultUpdateSchema(
results=body.results, status=enums.CMCPPlanningStatus.SUCCESS
)
else:
update = CMCPPlanningResultUpdateSchema(
error_msg=body.error_msg,
status=enums.CMCPPlanningStatus.FAILURE,
)
update.start_time = body.start_time
update.end_time = body.end_time
crud.cmcp_planning_result.update(db_obj=planning_result, obj_in=update)
# 使用此字段切换批次
max_pallets = order.supply_pallet_budget
# struct:
# {
# "sku_id_a": {
# "batch_id": "0",
# "pickable_quantity": 10,
# "pick_ws": "1",
# },
# "sku_id_b": {
# "batch_id": "1",
# "pickable_quantity": 11,
# "pick_ws": "2",
# },
# }
statistics_by_sku_id: OrderedDict[str, Dict] = collections.OrderedDict()
statistics_by_pallet_idx: OrderedDict[
int, Dict
] = collections.OrderedDict()
workspaces = collections.OrderedDict()
# 统计工作空间的可抓取数量和可放置数量
for result in body.results:
sku_id = result.sku_info.sku_id
pallet_idx = result.pallet_idx
if sku_id not in statistics_by_sku_id:
statistics_by_sku_id[sku_id] = {"pickable_quantity": 0}
if pallet_idx not in statistics_by_pallet_idx:
statistics_by_pallet_idx[pallet_idx] = {"placeable_quantity": 0}
if statistics_by_sku_id[sku_id].get("pick_ws", None) is None:
ws = self.workspace_manager.create_or_modify(
result.from_ws, False
)
workspaces[ws.ws_id] = ws
statistics_by_sku_id[sku_id]["pick_ws"] = ws.ws_id
if (
statistics_by_pallet_idx[pallet_idx].get("place_ws", None)
is None
):
ws = self.workspace_manager.create_or_modify(
result.to_ws, False
)
workspaces[ws.ws_id] = ws
statistics_by_pallet_idx[pallet_idx]["place_ws"] = ws.ws_id
statistics_by_sku_id[sku_id]["pickable_quantity"] += 1
statistics_by_pallet_idx[pallet_idx]["placeable_quantity"] += 1
# 将统计结果按照最大托盘来料数量进行批次切分
# [1, 2, 3, 4, 5]
# 如果 max_pallets = 2， 则切分为 [{ 1, 2 }, { 3, 4 }, { 5 }]
skus = list(statistics_by_sku_id.keys())
sku_groups = [
skus[i : i + max_pallets] for i in range(0, len(skus), max_pallets)
]
for batch_id, sku_group in enumerate(sku_groups):
for sku_id in sku_group:
statistics_by_sku_id[sku_id]["batch_id"] = str(batch_id)
# 创建任务
for result in body.results:
batch_id = statistics_by_sku_id[result.sku_info.sku_id].get(
"batch_id", None
)
task = CMCPTask(
task_id=str(uuid.uuid4()),
task_type=enums.TaskType.CONTROLLED_SEQ_MCP,
order_id=body.order_id,
batch_id=batch_id,
sku_info=result.sku_info,
target_num=1,
customized_data=result.customized_data,
from_ws=result.from_ws,
to_ws=result.to_ws,
pallet_idx=result.pallet_idx,
serial_num=result.serial_num,
)
# 将任务加入到任务管理器中，但此时 VP 还无法从任务管理器中获取到任务
# 因为此时任务都是未就绪的
self.task_manager.receive(task)
if batch_id:
task.bind_batch()
# 将托盘加入到工作空间
# 并将前 max_pallets 个托盘放入到工作空间, 表示工作空间中的当前托盘
for sku_id in statistics_by_sku_id.keys():
ws_id = statistics_by_sku_id[sku_id]["pick_ws"]
ws = workspaces[ws_id]
pickable_quantity = statistics_by_sku_id[sku_id][
"pickable_quantity"
]
pallet = Pallet(
pallet_id=sku_id + "_" + str(uuid.uuid4())[0:8],
workspace_id=ws.ws_id,
pickable_quantity=pickable_quantity,
placeable_quantity=-1,
)
ws.add_pallet(pallet)
if ws.current_pallet_id is None:
ws.pallet_in(pallet)
logger.info(f"托盘 '{pallet.pallet_id}' 已放入工作空间 '{ws.ws_id}'")
logger.info(
f"工作空间 '{ws.ws_id}' 已加入托盘 '{pallet.pallet_id}',"
f" Pallet: {pallet}"
)
for pallet_idx in statistics_by_pallet_idx.keys():
ws_id = statistics_by_pallet_idx[pallet_idx]["place_ws"]
ws = workspaces[ws_id]
placeable_quantity = statistics_by_pallet_idx[pallet_idx][
"placeable_quantity"
]
pallet = Pallet(
pallet_id=str(pallet_idx) + "_" + str(uuid.uuid4())[0:8],
workspace_id=ws.ws_id,
pickable_quantity=-1,
placeable_quantity=placeable_quantity,
)
ws.add_pallet(pallet)
if ws.current_pallet_id is None:
ws.pallet_in(pallet)
logger.info(f"托盘 '{pallet.pallet_id}' 已放入工作空间 '{ws.ws_id}'")
logger.info(
f"工作空间 '{ws.ws_id}' 已加入托盘 '{pallet.pallet_id}',"
f" Pallet: {pallet}"
)
# 向上游上报规划结果
self.callback_planning_result(order, statistics_by_sku_id)
return {}
def max_report_task_status(self, body: ReportTaskStatusInputSchema):
"""回报任务状态."""
task = self.task_manager.get_task_or_404(body.task_id)
order = task.order
if task.is_finished():
raise MAXException(_("任务 '{0}' 已完成，不可重复回报").format(task.task_id))
# 设置托盘为非新托盘
self.workspace_manager.not_new_pallet(task.to_ws)
to_ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
pallet = to_ws.get_current_pallet()
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
if body.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
body.drop_num, body.pick_num
)
)
if body.pick_num > 0:
task.report_pick_num(
body.pick_num,
auto_remove=False,
auto_complete=False,
)
if pallet:
# 减少当前托盘的可放置数量
pallet.dec_placeable_quantity(body.pick_num)
self.callback_one_cycle_finish(task, body.pick_num)
if task.done_num >= task.target_num:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
if pallet and pallet.is_full() or body.is_pal_pallet_full:
self.handle_workspace_is_full(to_ws)
# 拆垛盘空
if body.is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
self.handle_workspace_is_empty(ws)
if order is not None:
order.reload()
self.mp.order.info(
_("订单 '{0}' 的进度：{1}/{2}").format(
order.order_id, order.complete_num, order.total_num
)
)
return {
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
def max_report_task_status_v2(self, body: ReportTaskStatusInputV2Schema):
"""做 pick 点回报."""
if body.action != enums.Action.PICKED:
raise MAXException(_("对于控序混码订单，该接口仅支持 pick"))
result = body.results[0]
task = self.task_manager.get_task_or_404(result.task_id)
order = cast(CMCPOrder[CMCPTask], task.order)
# 将抓取工作空间中允许抓取的数量 -1
ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
if ws.is_new_pallet:
ws.not_new_pallet()
pallet = ws.get_current_pallet()
if pallet is None:
raise MAXException(_("工作空间 '{0}' 中没有托盘").format(task.from_ws))
# 将该托盘的可抓取数量 -1
pallet.dec_pickable_quantity()
if pallet.is_empty():
# ws.pallet_out()
self.handle_workspace_is_empty(ws)
return _list(
[
{
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
]
)
def max_report_task_ending(self, body: ReportTaskEndingInputSchema):
"""VP 上报任务结束."""
task_id = body.task_id
if not task_id:
raise MAXException(_("任务编号不能为空"))
task = self.task_manager.get_task_or_404(task_id)
order = self.order_manager.get_order_or_404(task.order_id)
if not (task.is_finished() or task.is_terminated()):
# 任务状态未完成
raise MAXException(
error_message=_("任务({0})未完成, 请勿调用").format(task_id)
).disable_msg_event()
# 上报订单完成
if self.auto_ready_next_task:
if self.is_batch_arrived and task.is_in_batch():
# 让该批次的下一个任务处于就绪状态
# 即 VP 可从任务队列中获取到该任务
next_task = task.next_task_in_batch()
if next_task is not None:
next_task.ready()
else:
# 当前批次没有任务，则向上游回报批次完成。
self.callback_batch_finish(
order_id=task.order_id, batch_id=task.batch_id # type: ignore
)
# 设置任务状态为已结束
task.end()
if order.is_finished():
# 设置订单已结束
order.end()
self.callback_order_finish(order)
else:
logger.warning(
"订单({})暂未完成，当前状态：{}, 当前进度 {}/{}".format(
order.order_id,
order.order_status,
order.completed_boxes_count,
order.total_boxes_count,
)
)
return {}
def max_get_next_task(self):
"""获取下一个任务, VP 用于异步视觉拍照校验."""
from xyz_max_hmi_server.templates.dpt.wcs_adaptor.schemas import (
SKUInfoOutputSchema,
TaskInfoOutputSchema,
)
try:
task = self.task_manager[1]
except XYZNotFoundError:
return TaskInfoOutputSchema()
# 如果当前任务为所属批次的最后一个任务，则返回空
if task.is_last_in_batch():
return TaskInfoOutputSchema()
return TaskInfoOutputSchema(
result=True,
task_id=task.task_id,
task_type=task.task_type,
from_ws=task.from_ws,
to_ws=task.to_ws,
sku_info=SKUInfoOutputSchema.parse_obj(task.sku_info),
target_num=task.target_num,
done_num=task.done_num,
undone_num=task.target_num - task.done_num,
customized_data=task.customized_data,
)
def callback_planning_result(
self,
order: CMCPOrder,
statistics_by_sku_id: dict,
):
"""回报WCS控序混码订单规划完成"""
planning_result = order.get_planning_result()
if not planning_result:
raise MAXException(
_("订单 '{0}' 不存在规划结果").format(order.order_id)
).disable_msg_event()
if statistics_by_sku_id:
status = True
m = {}
for sku_id, item in statistics_by_sku_id.items():
batch_id = item["batch_id"]
if batch_id not in m:
m[batch_id] = {
"batch_id": batch_id,
"order_id": order.order_id,
"total_quantity": 0,
"count_per_sku_id": collections.defaultdict(int),
}
m[batch_id]["total_quantity"] += item["pickable_quantity"]
m[batch_id]["count_per_sku_id"][sku_id] += item[
"pickable_quantity"
]
results = list(m.values())
else:
status = False
results = []
self.send_request_to_wcs(
self.api_report_planning_result,
{
"order_id": order.order_id,
"status": status,
"results": results,
"message": "success" if status else planning_result.error_msg,
},
)
if status:
self.mp.order.info(_("订单 '{0}' 规划成功").format(order.order_id))
else:
self.mp.order.error(
_("订单 '{0}' 规划失败，原因: {1}").format(
order.order_id, planning_result.error_msg
)
)
def callback_batch_finish(self, order_id: str, batch_id: str):
"""批次完成回调."""
data = {"order_id": order_id, "batch_id": batch_id}
self.send_request_to_wcs(self.api_report_batch_finish, data)
cmcp_workflow_pallet = CMCPWorkflowPallet()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\mcd_workflow.py | """Mixed Case Depalletting, 混拆"""
from typing import Optional
from wcs_adaptor.entity.order import MCDOrder
from wcs_adaptor.entity.task import MCDTask
from wcs_adaptor.schemas.wcs_schemas import OrderCreateSchema
from xyz_max_hmi_server import _
from xyz_max_hmi_server.exceptions import MAXException
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.templates.dpt.wcs_adaptor.schemas.max_schemas import (
ReportTaskStatusInputSchema,
ReportTaskStatusOutputSchema,
)
from .base import Workflow
class MCDWorkflow(Workflow):
"""混拆工作流"""
task_manager: TaskManager[MCDTask]
order_manager: OrderManager[MCDOrder[MCDTask]]
def wcs_create_order(self, body: OrderCreateSchema):
"""创建订单"""
order = MCDOrder(order_id=body.order_id)
n = len(body.order_items)
if n != 1:
raise MAXException(_("混拆订单只能有一个订单项"))
item = body.order_items[0]
try:
# NOTE: 混拆任务设置的 sku_info 是箱子的最大长宽高
task = MCDTask(
task_id=body.order_id,
order_id=body.order_id,
target_num=item.target_num or -1,
from_ws=item.from_options[0],
to_ws=item.to_options[0],
sku_info=item.sku_info,
)
except IndexError as e:
raise MAXException(_("混拆订单项的抓取位和放置位不能为空")) from e
self.order_manager.append(order)
self.task_manager.append(task)
self.mp.order.info(_("已创建混拆订单: '{0}'").format(order.order_id))
return self.make_response(data={"order_id": order.order_id})
def max_report_task_status(
self, body: ReportTaskStatusInputSchema, task: Optional[MCDTask] = None
):
"""上报任务状态(放置完成)
Args:
body: 上报任务状态请求体
task(Optional[RockyDualTask]): 任务实例
"""
if task is None:
task = self.task_manager.get_task_or_404(body.task_id)
if task.target_num == -1:
if body.pick_num > 0:
task.report_pick_num(body.pick_num)
self.mp.order.info(
_("混拆订单 '{0}' 本次完成的数量为 {1}, 共累计完成数: {2}").format(
task.order_id, body.pick_num, task.done_num
)
)
if body.drop_num and body.drop_num > 0:
self.mp.order.info(
_("混拆订单 '{0}' 发生掉箱，数量为 {1}").format(
task.order_id, body.drop_num
)
)
# 直到拆空
if body.is_depal_pallet_empty:
task.finish(
auto_remove=False,
auto_complete=True,
)
else:
# TODO: 指定 SKU 信息及数量进行拆垛
raise NotImplementedError("指定 SKU 信息及数量进行拆垛, 暂不支持.")
return ReportTaskStatusOutputSchema(
task_id=task.task_id,
is_task_finished=task.is_finished(),
is_order_finished=task.is_finished()
if task.target_num == -1
else False,
)
mcd_workflow = MCDWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\rmcp_workflow.py | from fastapi import BackgroundTasks
from loguru import logger
from wcs_adaptor.entity.task import RMCPTask
from wcs_adaptor.schemas.max_schemas import (
ReportTaskEndingInputSchema,
ReportTaskStatusInputV2Schema,
)
from wcs_adaptor.schemas.wcs_schemas import OrderCreateSchema
from xyz_max_hmi_server import _, enums
from xyz_max_hmi_server.entity.order import RMCPOrder
from xyz_max_hmi_server.exceptions import MAXException, WCSException
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.schemas.base import _list
from .base import Workflow
class RMCPWorkflow(Workflow):
"""无序混码工作流."""
order_manager: OrderManager[RMCPOrder[RMCPTask]]
task_manager: TaskManager[RMCPTask]
def wcs_create_order(
self, body: OrderCreateSchema, bg_tasks: BackgroundTasks
):
"""创建无序混码订单."""
order = self.order_manager.first()
# NOTE: 由于混码服务器同一时间只能处理一个订单(控序或无序)
# 所以，需要判断是否存在正在进行中的无序混码订单
if (
order
and order.is_started()
and order.order_type == enums.OrderType.CONTROLLED_SEQ_MCP
):
raise WCSException(error_message=_("当前存在正在进行中的控序混码订单，无法创建新的无序混码订单"))
order = RMCPOrder.parse_obj(body)
ws_ids = []
for pre_task in order.pre_tasks:
task = RMCPTask.parse_pre_task(pre_task)
order.add(task)
self.task_manager.append(task)
ws_ids.extend(task.to_options)
ws_ids.extend(task.from_options)
for _id in ws_ids:
# 默认为未就绪状态，等待上游通知工作空间就绪
self.workspace_manager.create_or_modify(ws_id=_id, is_ready=False)
self.order_manager.append(order)
self.mp.order.info(_("已收到无序混码订单 '{0}'").format(order.order_id))
return self.make_response(data={"order_id": order.order_id})
def max_report_task_status_v2(self, body: ReportTaskStatusInputV2Schema):
"""回报任务状态."""
def _handle_cycle_start(task, result):
task.start()
def _handle_cycle_reset(task, result):
task.reset()
def _handle_cycle_picked(task, result):
pass
def _handle_cycle_placed(task, result):
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
if result.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
result.drop_num, result.pick_num
)
)
# 如果任务已经放置到缓存区, 则不再处理
if body.is_in_buffer:
task.task_status = enums.TaskStatus.IN_BUFFER
self.mp.order.info(_("任务 '{0}' 已放置到缓存区").format(task.task_id))
return
if result.pick_num > 0:
order: RMCPOrder = task.order
assert isinstance(order, RMCPOrder)
task.report_pick_num(
result.pick_num,
auto_remove=False,
auto_complete=False,
)
if task.target_num == -1:
# 未知的目标数目，仅输出已抓取的数目
msg = _("订单 '{0}' 已完成抓放：{1}").format(
order.order_id,
task.done_num,
)
else:
# 已知的目标数目，即输出当前订单已完成的任务数目
msg = _("订单 '{0}' 已完成抓放：{1}/{2}").format(
order.order_id,
order.completed_boxes_count,
order.total_boxes_count,
)
self.mp.order.info(msg)
self.callback_one_cycle_finish(task, result.pick_num)
# 标记任务完成
# 当 target_num == -1 时
# 1. 如果码满，不处理
# 2. 如果码空，任务完成
# 当 target_num == 1 时，任务完成
if task.target_num == -1:
if body.is_pal_pallet_full:
return
elif body.is_depal_pallet_empty:
task.finish(
auto_remove=False,
auto_complete=True,
)
elif task.target_num == task.done_num:
task.finish(
auto_remove=False,
auto_complete=True,
)
action_map = {
enums.Action.START: _handle_cycle_start,
enums.Action.RESET: _handle_cycle_reset,
enums.Action.PICKED: _handle_cycle_picked,
enums.Action.PLACED: _handle_cycle_placed,
}
return_results = []
for result in body.results:
task = self.task_manager.get_task_or_404(result.task_id)
# 如果任务已经完成，直接跳过
if task.is_finished():
continue
action_map[body.action](task, result)
order = task.order
return_results.append(
{
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
)
if body.is_depal_pallet_empty and body.from_ws:
ws = self.workspace_manager.get_workspace_or_404(body.from_ws)
self.handle_workspace_is_empty(ws)
if body.is_pal_pallet_full and body.to_ws:
ws = self.workspace_manager.get_workspace_or_404(body.to_ws)
self.handle_workspace_is_full(ws)
return _list(return_results)
def max_report_task_ending(self, body: ReportTaskEndingInputSchema):
"""回报任务结束."""
tasks = []
order = None
def _handle_ending(task_id: str):
nonlocal order
task = self.task_manager.get_task_or_404(task_id)
if not (task.is_finished() or task.is_terminated()):
# 任务状态未完成
raise MAXException(
error_message=_("任务({0})未完成, 请勿调用").format(task_id)
).disable_msg_event()
# PERF: 因为回调函数可能超时并重试，这就意味当前 Sqlite 事务一直被占用, 所以这可能导致死锁
# 待事务提交之后，再调用回调函数
tasks.append(task)
# 设置任务状态为已结束
task.end()
if task.order_id is None:
return
order = self.order_manager.get_order_or_404(task.order_id)
if order.is_finished():
# 设置订单已结束
order.end()
self.callback_order_finish(order)
else:
logger.warning(
"订单({})暂未完成，当前状态：{}, 当前进度 {}/{}".format(
order.order_id,
order.order_status,
order.completed_boxes_count,
order.total_boxes_count,
)
)
for task_id in body.task_ids:
_handle_ending(task_id)
return {}
rmcp_workflow = RMCPWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\rockydual_unloading_workflow.py | """装卸车双臂工作流"""
from typing import Optional
from wcs_adaptor.entity.order import RockyDualUnloadingOrder
from wcs_adaptor.entity.task import RockyDualUnloadingTask
from wcs_adaptor.schemas.wcs_schemas import OrderCreateSchema
from xyz_max_hmi_server import _
from xyz_max_hmi_server.exceptions import XYZValidationError
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.templates.dpt.wcs_adaptor.schemas.max_schemas import (
ReportTaskStatusInputSchema,
ReportTaskStatusOutputSchema,
TaskInfoOutputSchema,
)
from .base import Workflow
class RockyDualUnloadingWorkflow(Workflow):
"""装卸车双臂拆垛工作流"""
order_manager: OrderManager[RockyDualUnloadingOrder[RockyDualUnloadingTask]]
task_manager: TaskManager[RockyDualUnloadingTask]
def max_get_container_info(self) -> dict:
"""获取车厢内径尺寸及车牌号"""
task = self.task_manager.first()
if not task:
return {}
return {
"truck_inner_dimension": task.truck_inner_dimension,
"license_plate_number": task.license_plate_number,
}
def max_get_task_info(self) -> TaskInfoOutputSchema:
"""获取任务信息"""
task = self.task_manager.first()
output = TaskInfoOutputSchema()
if not task:
return output
task.start()
output.result = True
output.target_num = task.target_num
output.done_num = task.done_num
output.undone_num = task.target_num
output.task_id = task.task_id
output.task_type = task.task_type
output.task_status = task.task_status
output.customized_data[
"license_plate_number"
] = task.license_plate_number
output.customized_data[
"truck_inner_dimension"
] = task.truck_inner_dimension
return output
def wcs_create_order(self, body: OrderCreateSchema):
"""创建订单"""
order = RockyDualUnloadingOrder(order_id=body.order_id)
self.order_manager.append(order)
quantity = len(body.order_items)
if body.truck_inner_dimension is None:
raise XYZValidationError(_("车厢尺寸不能为空"))
for key, val in body.truck_inner_dimension.items():
if val <= 0:
raise XYZValidationError(_("'{0}' 不能小于等于 0").format(key))
if quantity == 0:
# 拆空为止
task = RockyDualUnloadingTask(
task_id=body.order_id,
order_id=body.order_id,
target_num=-1,
license_plate_number=body.license_plate_number,
truck_inner_dimension={
"length": body.truck_inner_dimension["length"],
"width": body.truck_inner_dimension["width"],
"height": body.truck_inner_dimension["height"],
},
)
self.task_manager.append(task)
else:
# TODO: 指定 SKU 信息及数量进行拆垛
raise NotImplementedError("指定 SKU 信息及数量进行拆垛, 暂不支持.")
return self.make_response(data={"order_id": body.order_id})
def max_report_task_status(
self,
body: ReportTaskStatusInputSchema,
task: Optional[RockyDualUnloadingTask] = None,
) -> ReportTaskStatusOutputSchema:
"""上报任务状态(放置完成)
Args:
body: 上报任务状态请求体
task(Optional[RockyDualTask]): 任务实例
"""
if task is None:
task = self.task_manager.get_task_or_404(body.task_id)
if task.target_num == -1:
task.report_pick_num(body.pick_num)
# 直到拆空
if body.is_depal_pallet_empty:
task.finish(
auto_remove=False,
auto_complete=False,
)
self.callback_one_cycle_finish(task, body.pick_num)
else:
# TODO: 指定 SKU 信息及数量进行拆垛
raise NotImplementedError("指定 SKU 信息及数量进行拆垛, 暂不支持.")
return ReportTaskStatusOutputSchema(
task_id=task.task_id,
is_task_finished=task.is_finished(),
is_order_finished=task.is_finished()
if task.target_num == -1
else False,
)
def callback_one_cycle_finish(
self, task: RockyDualUnloadingTask, pick_num: int
):
"""一次循环完成回调"""
data = {
"order_id": task.order_id,
"pick_num": pick_num,
}
self.send_request_to_wcs(self.api_report_one_cycle_result, data)
def callback_order_finish(
self, order: RockyDualUnloadingOrder[RockyDualUnloadingTask]
):
"""订单完成回调"""
data = {
"order_id": order.order_id,
"done_num": order.complete_num,
}
self.send_request_to_wcs(self.api_report_order_status, data)
rockydual_unloading_workflow = RockyDualUnloadingWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\sd_workflow.py | from wcs_adaptor.entity.task import Task
from wcs_adaptor.schemas.max_schemas import (
ReportTaskStatusInputSchema,
ReportTaskStatusInputV2Schema,
)
from wcs_adaptor.schemas.wcs_schemas import OrderCreateSchema
from xyz_max_hmi_server import _, enums
from xyz_max_hmi_server.entity.order import Order
from xyz_max_hmi_server.exceptions import MAXException
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.schemas.base import _list
from .base import Workflow
class SingleDepalletizeWorkflow(Workflow):
"""单拆订单工作流"""
task_manager: TaskManager[Task]
order_manager: OrderManager[Order[Task]]
def wcs_create_order(self, body: OrderCreateSchema):
item = body.order_items[0]
if item.target_num is not None:
target_num = item.target_num
elif item.sku_info and item.sku_info.sku_num is not None:
target_num = item.sku_info.sku_num
else:
raise MAXException(_("单拆订单({0})的目标数量为空").format(body.order_id))
task = Task(
task_id=body.order_id,
task_type=enums.TaskType(body.order_type.value),
from_ws=item.from_options[0],
to_ws=item.to_options[0],
target_num=target_num,
sku_info=item.sku_info,
)
order = Order(
order_id=task.task_id,
order_type=body.order_type,
)
order.add(task)
self.task_manager.append(task)
self.order_manager.append(order)
# WARN: 默认上游下发单码订单时，抓取和放置空间都已就绪，is_ready=True
self.workspace_manager.create_or_modify(
ws_id=task.from_ws,
is_ready=True,
)
self.workspace_manager.create_or_modify(
ws_id=task.to_ws,
is_ready=True,
)
self.mp.order.info(
_("已收到单拆订单 '{0}'，待完成数量: {1}").format(task.task_id, task.target_num)
)
return self.make_response({"order_id": task.task_id})
def max_report_task_status_v2(self, body: ReportTaskStatusInputV2Schema):
"""回报任务状态(V2)."""
def _handle_drop(task, result):
"""掉箱处理"""
if result.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
result.drop_num, result.pick_num
)
)
def _handle_placed(task, result):
"""处理放置动作"""
if result.pick_num > 0:
task.report_pick_num(
result.pick_num,
auto_remove=False,
auto_complete=False,
)
self.mp.order.info(
_("任务进度: {0}/{1}").format(task.done_num, task.target_num)
)
self.callback_one_cycle_finish(task, result.pick_num)
def _handle_finish(task, result):
"""处理任务完成"""
# 判断任务完成的条件：
# 1.有目标数量且达到目标数量;
# 2.无指定目标数量且拆垛托盘已空或已满
in_range = 0 < task.target_num <= task.done_num
pallet_full = body.is_pal_pallet_full and task.target_num == -1
pallet_empty = body.is_depal_pallet_empty and task.target_num == -1
if in_range or pallet_full or pallet_empty:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
return_results = []
for result in body.results:
task = self.task_manager.get_task_or_404(result.task_id)
# 如果任务已经完成，直接跳过
if task.is_finished():
continue
if body.action == enums.Action.START:
task.start()
elif body.action == enums.Action.RESET:
task.reset()
elif body.action == enums.Action.PLACED:
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
_handle_drop(task, result)
# 放置成功, 更新任务完成数目
_handle_placed(task, result)
# 标记任务完成
_handle_finish(task, result)
elif body.action == enums.Action.PICKED:
# TODO:机械臂已抓取
pass
order = task.order
return_results.append(
{
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
)
task = self.task_manager.get_task_or_404(body.results[0].task_id)
from_ws = body.from_ws or task.from_ws
to_ws = body.to_ws or task.to_ws
is_pal_pallet_full = body.is_pal_pallet_full
is_depal_pallet_empty = body.is_depal_pallet_empty
# 码垛盘满
if is_pal_pallet_full:
ws = self.workspace_manager.get_workspace_or_404(to_ws)
self.handle_workspace_is_full(ws)
# 拆垛盘空
if is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(from_ws)
self.handle_workspace_is_empty(ws)
return _list(return_results)
def max_report_task_status(self, body: ReportTaskStatusInputSchema):
"""回报任务状态."""
task = self.task_manager.get_task_or_404(body.task_id)
order = task.order
if task.is_finished():
raise MAXException(_("任务({0})已完成，不可重复回报").format(task.task_id))
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
if body.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
body.drop_num, body.pick_num
)
)
if body.pick_num > 0:
task.report_pick_num(
body.pick_num,
auto_remove=False,
auto_complete=False,
)
self.mp.order.info(
_("任务进度: {0}/{1}").format(task.done_num, task.target_num)
)
self.callback_one_cycle_finish(task, body.pick_num)
# 判断任务完成的条件：
# 1.有目标数量且达到目标数量;
# 2.无指定目标数量且拆垛托盘已空或已满
in_range = 0 < task.target_num <= task.done_num
pallet_full = body.is_pal_pallet_full and task.target_num == -1
pallet_empty = body.is_depal_pallet_empty and task.target_num == -1
if in_range or pallet_full or pallet_empty:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
# 码垛盘满
if body.is_pal_pallet_full:
ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
self.handle_workspace_is_full(ws)
# 拆垛盘空
if body.is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
self.handle_workspace_is_empty(ws)
if order is not None:
order.reload()
return {
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
sd_workflow = SingleDepalletizeWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\sp_workflow.py | from wcs_adaptor.entity.task import Task
from wcs_adaptor.schemas.max_schemas import (
ReportTaskStatusInputSchema,
ReportTaskStatusInputV2Schema,
)
from wcs_adaptor.schemas.wcs_schemas import OrderCreateSchema
from xyz_max_hmi_server import _, enums
from xyz_max_hmi_server.entity.order import Order
from xyz_max_hmi_server.exceptions import MAXException
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from xyz_max_hmi_server.schemas.base import _list
from .base import Workflow
class SinglePalletizeWorkflow(Workflow):
"""单码订单工作流"""
task_manager: TaskManager[Task]
order_manager: OrderManager[Order[Task]]
def wcs_create_order(self, body: OrderCreateSchema):
item = body.order_items[0]
if item.target_num is not None:
target_num = item.target_num
elif item.sku_info and item.sku_info.sku_num is not None:
target_num = item.sku_info.sku_num
else:
raise MAXException(_("单码订单({0})的目标数量为空").format(body.order_id))
task = Task(
task_id=body.order_id,
task_type=enums.TaskType(body.order_type.value),
from_ws=item.from_options[0],
to_ws=item.to_options[0],
target_num=target_num,
sku_info=item.sku_info,
)
order = Order(
order_id=task.task_id,
order_type=body.order_type,
)
order.add(task)
self.task_manager.append(task)
self.order_manager.append(order)
# WARN: 默认上游下发单码订单时，抓取和放置空间都已就绪，is_ready=True
self.workspace_manager.create_or_modify(
ws_id=task.from_ws,
is_ready=True,
)
self.workspace_manager.create_or_modify(
ws_id=task.to_ws,
is_ready=True,
)
self.mp.order.info(
_("已收到单码订单 '{0}'，待完成数量: {1}").format(task.task_id, task.target_num)
)
return self.make_response({"order_id": body.order_id})
def max_report_task_status_v2(self, body: ReportTaskStatusInputV2Schema):
"""回报任务状态."""
def _handle_drop(task, result):
"""掉箱处理"""
if result.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
result.drop_num, result.pick_num
)
)
def _handle_placed(task, result):
"""处理放置动作"""
if result.pick_num > 0:
task.report_pick_num(
result.pick_num,
auto_remove=False,
auto_complete=False,
)
self.mp.order.info(
_("任务进度: {0}/{1}").format(task.done_num, task.target_num)
)
self.callback_one_cycle_finish(task, result.pick_num)
def _handle_finish(task, result):
"""处理任务完成"""
# 判断任务完成的条件：
# 1.有目标数量且达到目标数量;
# 2.无指定目标数量且拆垛托盘已空或已满
in_range = 0 < task.target_num <= task.done_num
pallet_full = body.is_pal_pallet_full and task.target_num == -1
pallet_empty = body.is_depal_pallet_empty and task.target_num == -1
if in_range or pallet_full or pallet_empty:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
return_results = []
for result in body.results:
task = self.task_manager.get_task_or_404(result.task_id)
# 如果任务已经完成，直接跳过
if task.is_finished():
continue
if body.action == enums.Action.START:
task.start()
elif body.action == enums.Action.RESET:
task.reset()
elif body.action == enums.Action.PLACED:
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
_handle_drop(task, result)
# 放置成功, 更新任务完成数目
_handle_placed(task, result)
# 标记任务完成
_handle_finish(task, result)
elif body.action == enums.Action.PICKED:
# TODO:机械臂已抓取
pass
order = task.order
return_results.append(
{
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
)
task = self.task_manager.get_task_or_404(body.results[0].task_id)
from_ws = body.from_ws or task.from_ws
to_ws = body.to_ws or task.to_ws
is_pal_pallet_full = body.is_pal_pallet_full
is_depal_pallet_empty = body.is_depal_pallet_empty
# 码垛盘满
if is_pal_pallet_full:
ws = self.workspace_manager.get_workspace_or_404(to_ws)
self.handle_workspace_is_full(ws)
# 拆垛盘空
if is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(from_ws)
self.handle_workspace_is_empty(ws)
return _list(return_results)
def max_report_task_status(self, body: ReportTaskStatusInputSchema):
"""回报任务状态."""
task: Task = self.task_manager.get_task_or_404(body.task_id)
order = task.order
if task.is_finished():
raise MAXException(_("任务({0})已完成，不可重复回报").format(task.task_id))
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
if body.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
body.drop_num, body.pick_num
)
)
if body.pick_num > 0:
task.report_pick_num(
body.pick_num,
auto_remove=False,
auto_complete=False,
)
self.mp.order.info(
_("任务进度: {0}/{1}").format(task.done_num, task.target_num)
)
self.callback_one_cycle_finish(task, body.pick_num)
# 判断任务完成的条件：
# 1.有目标数量且达到目标数量;
# 2.无指定目标数量且拆垛托盘已空或已满
in_range = 0 < task.target_num <= task.done_num
pallet_full = body.is_pal_pallet_full and task.target_num == -1
pallet_empty = body.is_depal_pallet_empty and task.target_num == -1
if in_range or pallet_full or pallet_empty:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
# 码垛盘满
if body.is_pal_pallet_full:
ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
self.handle_workspace_is_full(ws)
# 拆垛盘空
if body.is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
self.handle_workspace_is_empty(ws)
if order is not None:
order.reload()
return {
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
sp_workflow = SinglePalletizeWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\xlhb_sd_workflow.py | from typing import Optional
from loguru import logger
try:
from wcs_adaptor.entity.task import XLHBTask as Task
except ImportError:
from wcs_adaptor.entity.task import Task as _Task
class XLHBTask(_Task):
pass
Task = XLHBTask
from wcs_adaptor.schemas.max_schemas import (
ReportTaskEndingInputSchema,
ReportTaskStatusInputSchema,
)
from wcs_adaptor.schemas.wcs_schemas import SingleDepalletizeCreateSchema
from xyz_max_hmi_server import _, enums
from xyz_max_hmi_server.entity.order import Order
from xyz_max_hmi_server.exceptions import MAXException
from xyz_max_hmi_server.modules.error_map import ErrorMessage
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from .base import Workflow
class XLHBSingleDepalletizeWorkflow(Workflow):
"""单拆订单工作流（兼容 XLHB 的接口）"""
task_manager: TaskManager[Task]
order_manager: OrderManager[Order[Task]]
# 上报异常信息接口
api_report_exception = "/request/wcs/report_exception"
# 上报单次节拍执行结果接口
api_report_one_cycle_result = (
"/request/wcs/single_class_depal_task/report_action_status"
)
# 上报任务状态接口
api_report_task_status = (
"/request/wcs/single_class_depal_task/report_task_status"
)
def callback_one_cycle_finish(self, task: Task, pick_num: int):
self.send_request_to_wcs(
self.api_report_one_cycle_result,
{
"task_id": task.task_id,
"pick_num": pick_num,
"action_status": 0,
"customized_result": {},
"message": "ok",
},
)
def callback_task_finish(self, task: Task):
self.send_request_to_wcs(
self.api_report_task_status,
{
"task_id": task.task_id,
"task_status": 1,
"pick_num": task.done_num,
"target_num": task.target_num,
"message": "ok",
"customized_result": {},
},
)
def callback_exception(
self, error: ErrorMessage, task: Optional[Task] = None
):
self.send_request_to_wcs(
self.api_report_exception,
{
"error_code": error.code,
"error_msg": error.msg,
"zh_msg": error.tip,
},
)
def wcs_create_task(self, body: SingleDepalletizeCreateSchema):
try:
task = Task.parse_obj(body)
task.set_order_id(body.task_id)
order = Order(
order_id=body.task_id,
order_type=enums.OrderType(body.task_type.value),
)
self.task_manager.append(task)
self.order_manager.append(order)
self.workspace_manager.create_or_modify(
ws_id=task.from_ws, is_ready=body.clear_from_ws
)
self.workspace_manager.create_or_modify(
ws_id=task.to_ws, is_ready=body.clear_to_ws
)
message = _("已收到单拆订单({0})，待完成数量: {1}").format(
task.task_id, task.target_num
)
self.mp.order.info(message)
except Exception as e:
logger.exception(e)
self.mp.order.error(_("创建订单失败"))
return {
"error": -1,
"error_msg": "fail",
}
return {
"error": 0,
"error_msg": "success",
}
def wcs_abort_task(self, task_id: str):
"""中止任务."""
try:
order = self.order_manager.get_order_or_404(task_id)
except Exception:
return {
"error": -1,
"error_msg": "fail, order not found",
}
try:
self.wcs_abort_order(order)
except Exception:
return {
"error": -1,
"error_msg": "fail",
}
return {
"error": 0,
"error_msg": "success",
}
def max_report_task_status(self, body: ReportTaskStatusInputSchema):
"""回报任务状态."""
task = self.task_manager.get_task_or_404(body.task_id)
order = task.order
if task.is_finished():
raise MAXException(_("任务({0})已完成，不可重复回报").format(task.task_id))
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
if body.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
body.drop_num, body.pick_num
)
)
if body.pick_num > 0:
task.report_pick_num(
body.pick_num,
auto_remove=False,
auto_complete=False,
)
self.mp.order.info(
_("任务进度: {0}/{1}").format(task.done_num, task.target_num)
)
self.callback_one_cycle_finish(task, body.pick_num)
# 判断任务完成的条件：
# 1.有目标数量且达到目标数量;
# 2.无指定目标数量且拆垛托盘已空或已满
in_range = 0 < task.target_num <= task.done_num
pallet_full = body.is_pal_pallet_full and task.target_num == -1
pallet_empty = body.is_depal_pallet_empty and task.target_num == -1
if in_range or pallet_full or pallet_empty:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
# 码垛盘满
if body.is_pal_pallet_full:
ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
self.handle_workspace_is_full(ws)
# 拆垛盘空
if body.is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
self.handle_workspace_is_empty(ws)
if order is not None:
order.reload()
return {
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
def max_report_task_ending(self, body: ReportTaskEndingInputSchema):
"""回报任务结束."""
tasks = []
def _handle_ending(task_id: str):
task = self.task_manager.get_task_or_404(task_id)
if not (task.is_finished() or task.is_terminated()):
# 任务状态未完成
raise MAXException(
error_message=_("任务({0})未完成, 请勿调用").format(task_id)
).disable_msg_event()
# PERF: 因为回调函数可能超时并重试，这就意味当前 Sqlite 事务一直被占用, 所以这可能导致死锁
# 待事务提交之后，再调用回调函数
tasks.append(task)
# 设置任务状态为已结束
task.end()
if task.order_id is None:
return
order = self.order_manager.get_order_or_404(task.order_id)
if order.is_finished():
# 设置订单已结束
order.end()
else:
logger.warning(
"订单({})暂未完成，当前状态：{}, 当前进度 {}/{}".format(
order.order_id,
order.order_status,
order.done_num + order.end_num,
order.total_num,
)
)
for task_id in body.task_ids:
_handle_ending(task_id)
for task in tasks:
self.callback_task_finish(task)
return {}
xlhb_sd_workflow = XLHBSingleDepalletizeWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\xlhb_sp_workflow.py | from typing import Optional
from loguru import logger
try:
from wcs_adaptor.entity.task import XLHBTask as Task
except ImportError:
from wcs_adaptor.entity.task import Task as _Task
class XLHBTask(_Task):
pass
Task = XLHBTask
from wcs_adaptor.schemas.max_schemas import (
ReportTaskEndingInputSchema,
ReportTaskStatusInputSchema,
)
from wcs_adaptor.schemas.wcs_schemas import SinglePalletizeCreateSchema
from xyz_max_hmi_server import _, enums
from xyz_max_hmi_server.entity.order import Order
from xyz_max_hmi_server.exceptions import MAXException
from xyz_max_hmi_server.modules.error_map import ErrorMessage
from xyz_max_hmi_server.modules.manager.order_manager import OrderManager
from xyz_max_hmi_server.modules.manager.task_manager import TaskManager
from .base import Workflow
class XLHBSinglePalletizeWorkflow(Workflow):
"""单码订单工作流（兼容 XLHB 的接口）"""
task_manager: TaskManager[Task]
order_manager: OrderManager[Order[Task]]
# 上报异常信息接口
api_report_exception = "/request/wcs/report_exception"
# 上报单次节拍执行结果接口
api_report_one_cycle_result = (
"/request/wcs/single_class_pal_task/report_action_status"
)
# 上报任务状态接口
api_report_task_status = (
"/request/wcs/single_class_pal_task/report_task_status"
)
def callback_one_cycle_finish(self, task: Task, pick_num: int):
self.send_request_to_wcs(
self.api_report_one_cycle_result,
{
"task_id": task.task_id,
"pick_num": pick_num,
"action_status": 0,
"customized_result": {},
"message": "ok",
},
)
def callback_task_finish(self, task: Task):
self.send_request_to_wcs(
self.api_report_task_status,
{
"task_id": task.task_id,
"task_status": 1,
"pick_num": task.done_num,
"target_num": task.target_num,
"message": "ok",
"customized_result": {},
},
)
def callback_exception(
self, error: ErrorMessage, task: Optional[Task] = None
):
self.send_request_to_wcs(
self.api_report_exception,
{
"error_code": error.code,
"error_msg": error.msg,
"zh_msg": error.tip,
},
)
def wcs_create_task(self, body: SinglePalletizeCreateSchema):
"""创建单码订单/任务."""
try:
task = Task.parse_obj(body)
task.set_order_id(body.task_id)
order = Order(
order_id=body.task_id,
order_type=enums.OrderType(body.task_type.value),
)
self.task_manager.append(task)
self.order_manager.append(order)
self.workspace_manager.create_or_modify(
ws_id=task.from_ws, is_ready=body.clear_from_ws
)
self.workspace_manager.create_or_modify(
ws_id=task.to_ws, is_ready=body.clear_to_ws
)
message = _("已收到单码订单({0})，待完成数量: {1}").format(
task.task_id, task.target_num
)
self.mp.order.info(message)
except Exception as e:
logger.exception(e)
self.mp.order.error(_("创建订单失败"))
return {
"error": -1,
"error_msg": "fail",
}
return {
"error": 0,
"error_msg": "success",
}
def wcs_abort_task(self, task_id: str):
"""中止任务."""
try:
order = self.order_manager.get_order_or_404(task_id)
except Exception:
return {
"error": -1,
"error_msg": "fail, order not found",
}
try:
self.wcs_abort_order(order)
except Exception:
return {
"error": -1,
"error_msg": "fail",
}
return {
"error": 0,
"error_msg": "success",
}
def max_report_task_status(self, body: ReportTaskStatusInputSchema):
"""回报任务状态."""
task: Task = self.task_manager.get_task_or_404(body.task_id)
order = task.order
if task.is_finished():
raise MAXException(_("任务({0})已完成，不可重复回报").format(task.task_id))
# 如果有掉箱，提醒掉箱的数目，主要用于多抓的掉箱处理
if body.drop_num:
self.mp.order.error(
_("发生掉箱，本次掉箱的数目为: {0}，成功抓取的数目为: {1}").format(
body.drop_num, body.pick_num
)
)
if body.pick_num > 0:
task.report_pick_num(
body.pick_num,
auto_remove=False,
auto_complete=False,
)
self.mp.order.info(
_("任务进度: {0}/{1}").format(task.done_num, task.target_num)
)
self.callback_one_cycle_finish(task, body.pick_num)
# 判断任务完成的条件：
# 1.有目标数量且达到目标数量;
# 2.无指定目标数量且拆垛托盘已空或已满
in_range = 0 < task.target_num <= task.done_num
pallet_full = body.is_pal_pallet_full and task.target_num == -1
pallet_empty = body.is_depal_pallet_empty and task.target_num == -1
if in_range or pallet_full or pallet_empty:
# NOTE: 如果该任务存在订单，则将自动调用订单完成方法，表示该订单完成
task.finish(
auto_remove=False,
auto_complete=True,
)
# 码垛盘满
if body.is_pal_pallet_full:
ws = self.workspace_manager.get_workspace_or_404(task.to_ws)
self.handle_workspace_is_full(ws)
# 拆垛盘空
if body.is_depal_pallet_empty:
ws = self.workspace_manager.get_workspace_or_404(task.from_ws)
self.handle_workspace_is_empty(ws)
if order is not None:
order.reload()
return {
"task_id": task.task_id,
"is_task_finished": task.is_finished(),
"is_order_finished": (
order.is_finished() if order else task.is_finished()
),
}
def max_report_task_ending(self, body: ReportTaskEndingInputSchema):
"""回报任务结束."""
tasks = []
def _handle_ending(task_id: str):
task = self.task_manager.get_task_or_404(task_id)
if not (task.is_finished() or task.is_terminated()):
# 任务状态未完成
raise MAXException(
error_message=_("任务({0})未完成, 请勿调用").format(task_id)
).disable_msg_event()
# PERF: 因为回调函数可能超时并重试，这就意味当前 Sqlite 事务一直被占用, 所以这可能导致死锁
# 待事务提交之后，再调用回调函数
tasks.append(task)
# 设置任务状态为已结束
task.end()
if task.order_id is None:
return
order = self.order_manager.get_order_or_404(task.order_id)
if order.is_finished():
# 设置订单已结束
order.end()
else:
logger.warning(
"订单({})暂未完成，当前状态：{}, 当前进度 {}/{}".format(
order.order_id,
order.order_status,
order.done_num + order.end_num,
order.total_num,
)
)
for task_id in body.task_ids:
_handle_ending(task_id)
for task in tasks:
self.callback_task_finish(task)
return {}
xlhb_sp_workflow = XLHBSinglePalletizeWorkflow()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\dpt\wcs_adaptor\workflows\__init__.py | from .base import Workflow
workflow = Workflow()
from .cmcp_workflow import cmcp_workflow
from .cmcp_workflow_pallet import cmcp_workflow_pallet
try:
from .mcd_workflow import mcd_workflow
from .rmcp_workflow import rmcp_workflow
from .rockydual_unloading_workflow import rockydual_unloading_workflow
from .sd_workflow import sd_workflow
from .sp_workflow import sp_workflow
from .xlhb_sd_workflow import xlhb_sd_workflow
from .xlhb_sp_workflow import xlhb_sp_workflow
except ImportError:
pass
__all__ = [
"workflow",
"Workflow",
"cmcp_workflow",
"cmcp_workflow_pallet",
"rmcp_workflow",
"rockydual_unloading_workflow",
"sd_workflow",
"sp_workflow",
"xlhb_sd_workflow",
"xlhb_sp_workflow",
"mcd_workflow",
]
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\ind\config\default.yaml | system:
project_type: "ind"
db:
sqlalchemy_track_modifications: false
sqlalchemy_database_uri: "sqlite:///max_hmi.db?check_same_thread=false"
listener:
# VP 流图状态监听
vp_status:
enable: true
interval: 1
# TODO: replace `hmi` to `server`
hmi:
host: "0.0.0.0"
port: 7002
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\ind\wcs_adaptor\listener.py | """监听函数"""
from xyz_max_hmi_server.modules.message_pusher.sender import BaseSender
from xyz_max_hmi_server.modules.monitor import Listener
# class PLCStatusSender(BaseSender):
# """PLC 状态发送器"""
#
# event_type = "plc_status"
#
# def __call__(self, status):
# self.send({"status": status})
#
#
# plc_status_sender = PLCStatusSender()
#
#
# @Listener.register(name="PLC_STATUS", interval=1)
# def plc_status():
# """监听 plc 状态的回调函数"""
# from xyz_max_hmi_server.modules.plc import PLC
#
# address = 120
# result = PLC().read_signal(address)
# plc_status_sender(bool(result))
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\templates\ind\wcs_adaptor\main.py | from wcs_adaptor import version
from xyz_max_hmi_server import Application
from xyz_max_hmi_server.route import EnhancedAPIRoute
app = Application(
title="WCS Adaptor",
version=version.__version__,
description="WCS Adaptor",
)
app.router.route_class = EnhancedAPIRoute
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\cv_convert.py | import sys
import typing as t
import cv2
import numpy as np
if t.TYPE_CHECKING:
from xyz_max_hmi_server.modules.cyber.msgs import sensor_msgs
CV_TO_NUMPY_DTYPE = {
"mono8": "uint8",
"mono16": "uint16",
"bgr8": "uint8",
"rgb8": "uint8",
"bgr16": "uint16",
"rgb16": "uint16",
"rgba8": "uint8",
"bgra8": "uint8",
"rgba16": "uint16",
"bgra16": "uint16",
"32FC1": "float32",
"32FC2": "float32",
"32FC3": "float32",
"32FC4": "float32",
"64FC1": "float64",
"64FC2": "float64",
"64FC3": "float64",
"64FC4": "float64",
}
CV_TO_CHANNEL = {
"mono8": 1,
"mono16": 1,
"bgr8": 3,
"rgb8": 3,
"bgr16": 3,
"rgb16": 3,
"rgba8": 4,
"bgra8": 4,
"rgba16": 4,
"bgra16": 4,
"32FC1": 1,
"32FC2": 2,
"32FC3": 3,
"32FC4": 4,
"64FC1": 1,
"64FC2": 2,
"64FC3": 3,
"64FC4": 4,
}
def get_type_and_channels(encoding: str) -> t.Tuple[np.dtype, int]:
"""获取图像类型和通道数
Args:
encoding (str): 图像编码
Returns:
Tuple[str, int]: 图像类型和通道数
"""
assert encoding in CV_TO_NUMPY_DTYPE, f"Unsupported encoding {encoding}"
return np.dtype(CV_TO_NUMPY_DTYPE[encoding]), CV_TO_CHANNEL[encoding]
def imgmsg_to_cv2(imgmsg: "sensor_msgs.Image"):
"""将 sensor_msgs/Image 转换为 cv2 图像
Args:
imgmsg (sensor_msgs.Image): 图像消息
Returns:
np.ndarray: cv2 图像
"""
dtype, channels = get_type_and_channels(imgmsg.encoding)
dtype = dtype.newbyteorder(">" if imgmsg.is_bigendian else "<")
img_buf = (
np.asarray(imgmsg.data, dtype=dtype)
if isinstance(imgmsg.data, list)
else imgmsg.data
)
if channels == 1:
im = np.ndarray(
shape=(imgmsg.height, int(imgmsg.step / dtype.itemsize)),
dtype=dtype,
buffer=img_buf,
)
im = np.ascontiguousarray(im[: imgmsg.height, : imgmsg.width])
else:
im = np.ndarray(
shape=(
imgmsg.height,
int(imgmsg.step / dtype.itemsize / channels),
channels,
),
dtype=dtype,
buffer=img_buf,
)
im = np.ascontiguousarray(im[: imgmsg.height, : imgmsg.width, :])
if bool(imgmsg.is_bigendian) == (sys.byteorder == "little"):
im = im.byteswap().newbyteorder()
return im
def cv2_to_bts(im, imgmsg: "sensor_msgs.Image", scale: int = 1) -> bytes:
"""将 cv2 图像转换为 bytes
Args:
im: cv2 图像
imgmsg (sensor_msgs.Image): 图像消息
scale: 缩放比例
Returns:
bytes: 图像数据
"""
img = cv2.cvtColor(im, cv2.COLOR_BGR2RGB)
img = cv2.resize(img, (imgmsg.width // scale, imgmsg.height // scale))
img_encode = cv2.imencode(".png", img)[1]
data_encode = np.array(img_encode)
imgmsg.height //= scale
imgmsg.width //= scale
return data_encode.tobytes()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\db_util.py | import os
from pathlib import Path
from typing import Callable, Optional, Sequence, TypeVar, Union
from alembic import command, config
from fastapi_pagination import paginate as _paginate
from fastapi_pagination.bases import AbstractPage, AbstractParams
from fastapi_pagination.ext.sqlalchemy import paginate as _paginate_sqlalchemy
from fastapi_pagination.types import AdditionalData
from sqlalchemy import create_engine
from sqlalchemy.orm import Query
from sqlalchemy.sql import Select
from xyz_max_hmi_server import migrations
from xyz_max_hmi_server.config import settings
T = TypeVar("T")
def paginate(
query: Union[Query, Select, Sequence[T]],
params: Optional[AbstractParams] = None,
length_function: Callable[[Sequence[T]], int] = len,
*,
additional_data: AdditionalData = None,
) -> AbstractPage[T]:
"""分页"""
if isinstance(query, Query):
return _paginate_sqlalchemy(
query,
params,
additional_data=additional_data,
)
elif isinstance(query, Select):
raise NotImplementedError(
"Pagination for sqlalchemy select is not implemented"
)
# return _paginate_sqlalchemy(
# query,
# params,
# additional_data=additional_data,
# )
else:
return _paginate(
query,
params,
length_function,
additional_data=additional_data,
)
def _migrate_db():
# 创建数据库
uri = settings.db.sqlalchemy_database_uri
if uri.startswith("sqlite"):
pass
else:
if t := uri.rsplit("/", 1):
db_name = t[-1].split("?")[0]
else:
raise ValueError("Invalid MySQL DSN")
engine = create_engine(
settings.db.sqlalchemy_database_uri.split("?")[0].rsplit("/", 1)[0]
)
conn = engine.connect()
conn.execute(f"CREATE DATABASE IF NOT EXISTS {db_name};")
conn.close()
# HACK: 通过切换工作目录的方式，将数据库文件生成到项目目录下
# almebic 应该有更好的方式
current_dir = os.getcwd()
os.chdir(settings.project_dir)
# 初始化数据表
migration_dir = Path(migrations.__file__).parent
alembic_config = config.Config(migration_dir.parent / "alembic.ini")
alembic_config.set_main_option("script_location", migration_dir.as_posix())
command.upgrade(alembic_config, "head")
os.chdir(current_dir)
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\decorators.py | import time
from functools import wraps
from typing import Callable, Optional, Type, TypeVar
from loguru import logger
from typing_extensions import ParamSpec, TypeVar
T = TypeVar("T")
P = ParamSpec("P")
# FIXME: 被装饰的方法/函数的返回值的类型没有被正确推导.
def skip(
condition: Callable[..., bool]
) -> Callable[[Callable[P, T]], Callable[P, Optional[T]]]:
"""根据条件跳过被装饰的方法/函数.
Examples:
>>> @skip(lambda x: x == 1)
... def func(x):
... print(x)
...
>>> func(1)
>>> func(2)
2
"""
def decorator(func: Callable[P, T]) -> Callable[P, Optional[T]]:
@wraps(func)
def wrapper(*args: P.args, **kwargs: P.kwargs) -> Optional[T]:
if condition(*args, **kwargs):
return
return func(*args, **kwargs)
return wrapper
return decorator
def reraise(
old_exception: Type[Exception],
exception: Type[Exception],
message: Optional[str] = None,
) -> Callable[[Callable[P, T]], Callable[P, T]]:
"""捕获 Exception 类型的异常，重新抛出为指定的异常类型.
用于解决绝大多数内部库全是 Exception 类型的异常，而我们需要捕获指定类型的异常的场景.
Examples:
>>> @reraise(Exception, ValueError, "message")
... def func():
... raise Exception
...
>>> func()
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
File "<stdin>", line 4, in func
ValueError: message
"""
def decorator(func: Callable[P, T]) -> Callable[P, T]:
@wraps(func)
def wrapper(*args: P.args, **kwargs: P.kwargs) -> T:
try:
return func(*args, **kwargs)
except old_exception as e:
raise exception(message or str(e)) from e
return wrapper
return decorator
M = {}
def retry(
max_waittime: int = 32,
retry_condition: Optional[Callable[..., bool]] = None,
):
"""重试装饰器.
为了避免阻塞其他线程, 这里使用了指数退避算法.
Args:
max_waittime: 最大等待时间, 单位为秒.
retry_condition: 重试条件, 返回 True 时重试, 返回 False 时不重试.
Examples:
>>> @retry()
... def func():
... raise Exception
"""
def decorator(func):
M[func.__name__] = 0
@wraps(func)
def wrapper(*args, **kwargs):
if M[func.__name__] > 0:
time.sleep(min(2 ** M[func.__name__], max_waittime))
try:
r = func(*args, **kwargs)
M[func.__name__] = 0
return r
except Exception as e:
if retry_condition is not None and not retry_condition(e):
raise e
if M[func.__name__] < 5:
M[func.__name__] += 1
raise e
return wrapper
return decorator
def retry_cyber_connect(
max_waittime: int = 32,
) -> Callable[[Callable[..., T]], Callable[..., Optional[T]]]:
"""用于重试 Cyber Connect 的装饰器.
当 Cyber 服务未启动时, 会抛出 `connect to server` 的异常， 该异常会阻塞程序的运行.
所以按间隔重试，避免阻塞其他线程.
"""
def _cond(e):
return "connect to server" in str(e)
return retry_exponential_backoff(
max_waittime=max_waittime, retry_condition=_cond
)
# 指数退避算法
# https://en.wikipedia.org/wiki/Exponential_backoff
def retry_exponential_backoff(
max_waittime: int = 32,
retry_condition: Optional[Callable[..., bool]] = None,
) -> Callable[[Callable[..., T]], Callable[..., Optional[T]]]:
"""指数退避算法的重试装饰器.
为了避免阻塞其他线程, 这里使用了指数退避算法.
Args:
max_waittime: 最大等待时间, 单位为秒.
retry_condition: 重试条件, 返回 True 时重试, 返回 False 时不重试.
Examples:
>>> @retry_exponential_backoff()
... def func():
... raise Exception
"""
def decorator(func: Callable[..., T]) -> Callable[..., Optional[T]]:
M[func.__name__] = (0, 0)
@wraps(func)
def wrapper(*args, **kwargs) -> Optional[T]:
if M[func.__name__][1] > time.time():
return
try:
r = func(*args, **kwargs)
M[func.__name__] = (0, 0)
return r
except Exception as e:
if retry_condition is not None and not retry_condition(e):
raise e
i = M[func.__name__][0]
next_exec_time = time.time() + min(2 ** min(i, 5), max_waittime)
M[func.__name__] = (i + 1, next_exec_time)
return wrapper
return decorator
def cache(expire: float):
"""缓存装饰器，用于缓存函数的返回值.
Args:
expire: 缓存过期时间，单位为秒.
"""
def decorator(func):
cache = {}
@wraps(func)
def wrapper(*args, **kwargs):
key = (id(func), args, tuple(kwargs.items()))
if key in cache:
if time.time() - cache[key]["time"] < expire:
return cache[key]["value"]
value = func(*args, **kwargs)
cache[key] = {"value": value, "time": time.time()}
return value
return wrapper
return decorator
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\generic_model.py | from typing import Any, Generic, Tuple, Type, TypeVar, Union
from pydantic.generics import GenericModel as _GenericModel, GenericModelT
T = TypeVar("T")
# NOTICE: This is a workaround for the issue:
# https://github.com/pydantic/pydantic/discussions/4904
class GenericModel(_GenericModel):
def __class_getitem__(
cls: Type[GenericModelT],
params: Union[Type[Any], Tuple[Type[Any], ...]],
) -> Type[Any]:
create_model = super().__class_getitem__(params)
class _Generic(Generic[T]):
pass
create_model.__orig_class__ = _Generic[params] # type: ignore
return create_model
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\i18n.py | from fastapi_babel import Babel, _
def change_locale(
babel: Babel,
locale: str,
):
"""修改语言."""
babel.locale = locale
gettext = _
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\message2jsonschema.py | from typing import Dict, Optional, Sequence, Type, Union
from google.protobuf.descriptor import FieldDescriptor
from google.protobuf.message import Message
from loguru import logger
# PERF: lru_cache 无法缓存 Message，因为 Message 是 Unhashable 的.
@logger.catch()
def message2jsonschema(
message: Union[Message, Type[Message]],
name: Optional[str] = None,
required: Optional[Sequence] = None,
definitions: Optional[Dict] = None,
):
"""Convert a protobuf message to a JSON schema.
Args:
message: A protobuf message.
name: The name of the message.
required: A list of required fields.
definitions: A dictionary of definitions.
Returns:
A JSON schema.
"""
if isinstance(message, Message):
message = message.__class__
if name is None:
name = message.DESCRIPTOR.name
if required is None:
required = []
if definitions is None:
definitions = {}
schema = {
"type": "object",
"title": name,
"properties": {},
"required": list(required),
"definitions": definitions,
}
for field in message.DESCRIPTOR.fields:
if field.label == field.LABEL_REPEATED:
schema["properties"][field.name] = {
"type": "array",
"items": field2jsonschema(field, definitions),
}
else:
schema["properties"][field.name] = field2jsonschema(
field, definitions
)
return schema
def field2jsonschema(field, definitions):
"""Convert a protobuf field to a JSON schema.
Args:
field: A protobuf field.
definitions: A dictionary of definitions.
Returns:
A JSON schema.
"""
if field.message_type:
# Composite field
name = field.message_type.name
if name not in definitions:
definitions[name] = message2jsonschema(
field.message_type._concrete_class,
name,
# definitions=definitions,
)
return {"$ref": "#/definitions/" + name}
else:
# Raw type
return {
"type": field_type2jsonschema(field.type),
"format": field_format2jsonschema(field.type),
}
def field_type2jsonschema(field_type: int):
"""Convert a protobuf field type to a JSON schema type.
Args:
field_type: A protobuf field type.
Returns:
A JSON schema type.
"""
if field_type == FieldDescriptor.TYPE_DOUBLE:
return "number"
elif field_type == FieldDescriptor.TYPE_FLOAT:
return "number"
elif field_type == FieldDescriptor.TYPE_INT64:
return "integer"
elif field_type == FieldDescriptor.TYPE_UINT64:
return "integer"
elif field_type == FieldDescriptor.TYPE_INT32:
return "integer"
elif field_type == FieldDescriptor.TYPE_FIXED64:
return "integer"
elif field_type == FieldDescriptor.TYPE_FIXED32:
return "integer"
elif field_type == FieldDescriptor.TYPE_BOOL:
return "boolean"
elif field_type == FieldDescriptor.TYPE_STRING:
return "string"
elif field_type == FieldDescriptor.TYPE_BYTES:
return "string"
elif field_type == FieldDescriptor.TYPE_UINT32:
return "integer"
elif field_type == FieldDescriptor.TYPE_SFIXED32:
return "integer"
elif field_type == FieldDescriptor.TYPE_SFIXED64:
return "integer"
elif field_type == FieldDescriptor.TYPE_SINT32:
return "integer"
elif field_type == FieldDescriptor.TYPE_SINT64:
return "integer"
else:
raise ValueError("Unknown field type: {}".format(field_type))
def field_format2jsonschema(field_type: int):
"""Convert a protobuf field type to a JSON schema format.
Args:
field_type: A protobuf field type.
Returns:
A JSON schema format.
"""
if field_type == FieldDescriptor.TYPE_DOUBLE:
return "double"
elif field_type == FieldDescriptor.TYPE_FLOAT:
return "float"
elif field_type == FieldDescriptor.TYPE_INT64:
return "int64"
elif field_type == FieldDescriptor.TYPE_UINT64:
return "uint64"
elif field_type == FieldDescriptor.TYPE_INT32:
return "int32"
elif field_type == FieldDescriptor.TYPE_FIXED64:
return "uint64"
elif field_type == FieldDescriptor.TYPE_FIXED32:
return "uint32"
elif field_type == FieldDescriptor.TYPE_BOOL:
return "boolean"
elif field_type == FieldDescriptor.TYPE_STRING:
return "string"
elif field_type == FieldDescriptor.TYPE_BYTES:
return "byte"
elif field_type == FieldDescriptor.TYPE_UINT32:
return "uint32"
elif field_type == FieldDescriptor.TYPE_SFIXED32:
return "int32"
elif field_type == FieldDescriptor.TYPE_SFIXED64:
return "int64"
elif field_type == FieldDescriptor.TYPE_SINT32:
return "int32"
elif field_type == FieldDescriptor.TYPE_SINT64:
return "int64"
else:
raise ValueError("Unknown field type: {}".format(field_type))
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\openapi.py | import copy
import textwrap
from fastapi.openapi.utils import get_openapi
from xyz_max_hmi_server.config import settings
from xyz_max_hmi_server.route import EnhancedAPIRoute
def init_app(app, subapp):
"""初始化应用"""
def custom_openapi():
"""自定义 OpenAPI 文档"""
if app.openapi_schema:
return app.openapi_schema
replaced_routes = []
for route in subapp.routes:
if not route.path.startswith("/api"):
continue
route = copy.copy(route)
route.path_format = route.path.replace("/api", "/adaptor/api", 1)
replaced_routes.append(route)
app.openapi_schema = get_openapi(
title=app.title + f" - {settings.system.project_type.name}",
version=app.version,
openapi_version=app.openapi_version,
description=app.description,
terms_of_service=app.terms_of_service,
contact=app.contact,
license_info=app.license_info,
routes=app.routes + replaced_routes,
tags=app.openapi_tags,
servers=app.servers
+ [{"url": "/"}, {"url": "http://localhost:7002/"}],
)
extend_openapi(app)
return app.openapi_schema
app.openapi = custom_openapi
app.description = textwrap.dedent(
f"""
HMI 服务端，为 Studio Max 提供 API 服务并以插件形式适配业务方的需求。\n
---
概要：
- 项目类型：{settings.system.project_type.name}
- WCS Adaptor 版本：{subapp.version}
"""
)
def extend_openapi(app) -> None:
if not app.openapi_schema:
return
# 添加 tags, 从 path 中提取
tags = []
tag_names = set()
for path in app.openapi_schema["paths"].values():
for method in path.values():
for tag_name in method.get("tags", []):
tag_names.add(tag_name)
for tag_name in sorted(tag_names):
tags.append({"name": tag_name})
app.openapi_schema["tags"] = tags
app.openapi_schema["components"]["schemas"]["HTTPValidationError"] = {
"title": "HTTPValidationError",
"type": "object",
"required": ["code", "msg", "data"],
"properties": {
"code": {
"title": "Code",
"type": "integer",
"nullable": False,
"default": -1,
},
"msg": {
"title": "Message",
"type": "string",
"nullable": False,
},
"data": {
"title": "Data",
"type": "object",
"nullable": False,
"required": ["error_code", "error_msg", "detail"],
"properties": {
"error_code": {
"title": "Error Code",
"type": "string",
"nullable": False,
},
"error_msg": {
"title": "Error Message",
"type": "string",
"nullable": False,
},
"details": {
"title": "Details",
"type": "array",
"items": {
"$ref": "#/components/schemas/ValidationError"
},
},
},
},
},
}
app.openapi_schema["components"]["schemas"]["InternalError"] = {
"title": "InternalError",
"type": "object",
"required": ["code", "msg", "data"],
"properties": {
"code": {
"title": "Code",
"type": "integer",
"nullable": False,
"default": -1,
},
"msg": {
"title": "Message",
"type": "string",
"nullable": False,
},
"data": {
"title": "Data",
"type": "object",
"nullable": False,
"required": ["error_code", "error_msg"],
"properties": {
"error_code": {
"title": "Error Code",
"type": "string",
"nullable": False,
},
"error_msg": {
"title": "Error Message",
"type": "string",
"nullable": False,
},
},
},
},
}
http500 = {
"description": "Internal Server Error",
"content": {
"application/json": {
"schema": {"$ref": "#/components/schemas/InternalError"}
}
},
}
# 遍历所有的路由，将 500 错误的响应体替换为自定义的响应体
for path, path_item in app.openapi_schema["paths"].items():
for method, operation in path_item.items():
if method == "parameters":
continue
operation["responses"]["500"] = http500
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\request.py | import os
import time
from typing import Literal, Optional, Tuple, Union
import requests
from loguru import logger
from xyz_max_hmi_server import _
from xyz_max_hmi_server.config import settings
from xyz_max_hmi_server.exceptions import XYZException
from xyz_max_hmi_server.utils.decorators import skip
_session = requests.Session()
def is_skip(*args, **kwargs) -> bool:
env = os.getenv("MAX_HMI_ENV")
if env == "production" or env == "mock":
return False
return True
@skip(condition=is_skip)
def request_by_http(
path: Optional[str] = None,
data: Optional[dict] = None,
scheme: Literal["http", "https"] = "http",
method: Literal["GET", "POST"] = "POST",
timeout: Union[float, Tuple[float, float]] = (0.5, 0.5),
until_success: bool = False,
retry: int = 3,
retry_interval: float = 0.2,
url: Optional[str] = None,
) -> Optional[requests.Response]:
"""请求接口.
仅生产环境下才会请求接口, 否则直接返回None.
Args:
path: 请求路径
data: 请求数据
timeout: 超时时间
until_success: 是否一直重试直到成功
retry: 重试次数
url: 请求地址
Raises:
requests.exceptions.RequestException: 请求异常
Exception: 其他异常
Returns:
requests.Response: 响应对象
"""
if data is None:
data = {}
if settings.dev_mode.mock_wcs:
host = "127.0.0.1"
else:
host = settings.wcs.host
if not url:
if path:
url = f"{scheme}://{host}:{settings.wcs.port}/{path.strip('/')}"
else:
raise ValueError("请求地址和请求路径不能同时为空")
def _request() -> requests.Response:
logger.debug(f"请求地址: {url}, 请求数据: {data}")
if method == "POST":
response = _session.post(url, json=data, timeout=timeout)
elif method == "GET":
response = _session.get(url, params=data, timeout=timeout)
else:
raise ValueError(f"不支持的请求方法: {method}")
logger.debug(f"请求地址: {url}, 响应数据: {response.content}")
return response
i = -1
last_exception = None
while 1:
if i >= retry and not until_success:
if i >= 1:
logger.warning(f"{url} 重试请求次数已达上限, 放弃该请求")
break
try:
resp = _request()
resp.raise_for_status()
return resp
except requests.exceptions.RequestException as e:
last_exception = e
logger.error(f"[{i}] - {url} - 请求失败: {e}")
i += 1
if i >= 1:
time.sleep(retry_interval)
raise XYZException(f"{url} - " + _("请求上游失败: ") + f"{last_exception}")
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\signleton.py | """单例元类"""
class Singleton(type):
"""单例元类.
Example:
>>> class A(metaclass=Singleton):
pass
>>> a1 = A()
>>> a2 = A()
>>> assert a1 is a2
"""
instances = {}
def __call__(cls, *args, **kwargs):
if cls not in cls.instances:
cls.instances[cls] = super().__call__(*args, **kwargs)
return cls.instances[cls]
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\studio_max.py | """
用于 Studio Max 的一些工具函数
"""
import configparser
import os
import re
from pathlib import Path
from typing import Optional, Union
# 判断当前系统是否为 Windows
IS_WINDOWS = os.name == "nt"
unicode_pattern = re.compile(r"(?!\\u[0-9a-fA-F]{4})\\u([0-9a-fA-F]{2})")
def read_hkey(
key: str, path: str = r"Software\XYZ Robotics\xyz_studio_max"
) -> Optional[str]:
"""
读取注册表的值(Windows)
"""
import winreg
try:
with winreg.OpenKey(winreg.HKEY_CURRENT_USER, path) as hkey: # type: ignore
return winreg.QueryValueEx(hkey, key)[0] # type: ignore
except FileNotFoundError:
return None
def write_hkey(
key: str, value: str, path: str = r"Software\XYZ Robotics\xyz_studio_max"
) -> None:
"""
写入注册表的值(Windows)
"""
import winreg
with winreg.CreateKey(winreg.HKEY_CURRENT_USER, path) as hkey: # type: ignore
winreg.SetValueEx(hkey, key, 0, winreg.REG_SZ, value) # type: ignore
def read_conf(
key: str, path: str = r"~/.config/XYZ Robotics/xyz_studio_max.conf"
) -> Optional[str]:
"""
读取配置文件(Linux)
"""
path = os.path.expanduser(path)
if not os.path.exists(path):
return None
# TODO: 使用 configparser 简化
with open(path, "r", encoding="utf-8") as f:
for line in f:
if not line.startswith(key):
continue
val = line.split("=")[1].strip()
# /home/xyz/Documents/XYZRobotics/\u7a7a\u767d\u9879\u76ee_2
# /home/xyz/Documents/XYZRobotics/空白项目_2
val = val.replace("\\x", "\\u")
result = unicode_pattern.sub(r"\\u00\1", val)
return result.encode().decode("unicode_escape")
raise KeyError(f"Key '{key}' not found in config file.")
def write_conf(
key: str,
value: str,
path: str = r"~/.config/XYZ Robotics/xyz_studio_max.conf",
) -> None:
"""写入配置文件(Linux)"""
c = configparser.ConfigParser()
c.add_section("General")
c.set("General", key, value)
path = os.path.expanduser(path)
os.makedirs(os.path.dirname(path), exist_ok=True)
with open(path, "w", encoding="utf-8") as f:
c.write(f)
def get_current_project_dir() -> Optional[Path]:
"""
获取当前项目的路径
"""
if IS_WINDOWS:
if val := read_hkey("current_project_root_dir"):
# HACK: 由于 Studio Max 的 bug, 当前项目目录会被设置为当前用户目录,
# 所以这里需要特殊判断
if val != "C:/Users/xyz":
return Path(val)
# 读取最近打开的项目中的第一个
if val := read_hkey("recent_projects_path"):
return Path(val[0].rsplit("/", 1)[0])
else:
if val := read_conf("current_project_root_dir"):
# HACK: 同上
if val != "/home/xyz":
return Path(val)
return Path(val)
# 读取最近打开的项目中的第一个
if val := read_conf("recent_projects_path"):
return Path(val[0].rsplit("/", 1)[0])
return None
def get_max_bin_dir() -> Optional[Path]:
"""获取 Studio Max 的 bin 目录"""
if IS_WINDOWS:
if val := read_hkey("application_dir_path"):
return Path(val)
else:
if val := read_conf("application_dir_path"):
return Path(val)
return None
def get_log_file_path() -> Optional[Path]:
"""
获取当前项目的日志文件路径
"""
if IS_WINDOWS:
if val := read_hkey("log_file_path"):
return Path(val)
else:
if val := read_conf("log_file_path"):
return Path(val)
return None
def get_current_hmi_project_name() -> Optional[str]:
"""获取当前 HMI 项目的名称"""
if IS_WINDOWS:
if val := read_hkey(
"current_project_name", r"Software\XYZ Robotics\xyz_max_hmi_server"
):
return val
else:
try:
if val := read_conf(
"current_project_name",
r"~/.config/XYZ Robotics/xyz_max_hmi_server.conf",
):
return val
except KeyError:
pass
return None
def set_current_hmi_project_name(name: str) -> None:
"""设置当前 HMI 项目的名称"""
if IS_WINDOWS:
write_hkey(
"current_project_name",
name,
r"Software\XYZ Robotics\xyz_max_hmi_server",
)
else:
write_conf(
"current_project_name",
name,
r"~/.config/XYZ Robotics/xyz_max_hmi_server.conf",
)
def get_current_hmi_project_dir() -> Optional[Path]:
"""获取当前 HMI 项目的路径"""
project_dir = get_current_project_dir()
if not project_dir:
return None
hmi_project_name = get_current_hmi_project_name()
if not hmi_project_name:
return None
return project_dir / f"hmi/{hmi_project_name}"
class XYZRoboticsSettings:
"""XYZ Robotics 配置"""
def __init__(self) -> None: # noqa: D107
if IS_WINDOWS:
self._config_path = r"Software\XYZ Robotics"
else:
self._config_path = os.path.expanduser(r"~/.config/XYZ Robotics")
os.makedirs(self._config_path, exist_ok=True)
def set(
self, key: str, value: str, srv_name: str, section: str = "General"
) -> None:
"""设置配置项
Args:
key: 配置项名称
value: 配置项值
srv_name: 服务名称
section: 配置项所在的节, 默认为 General
"""
if IS_WINDOWS:
write_hkey(key, value, self._config_path + f"\\{srv_name}")
else:
self._config = configparser.ConfigParser()
self._config.read(self._config_path + f"/{srv_name}.conf")
if not self._config.has_section(section):
self._config.add_section(section)
self._config.set(section, key, value)
with open(self._config_path, "w", encoding="utf-8") as f:
self._config.write(f)
def get(
self, key: str, srv_name: str, section: str = "General"
) -> Optional[str]:
"""获取配置项
Args:
key: 配置项名称
srv_name: 服务名称
section: 配置项所在的节, 默认为 General
Returns:
Optional[str]: 配置项值
"""
if IS_WINDOWS:
return read_hkey(key, self._config_path + f"\\{srv_name}")
else:
self._config = configparser.ConfigParser()
self._config.read(self._config_path + f"/{srv_name}.conf")
try:
return self._config[section].get(key, None)
except KeyError:
return None
# TODO: 写一个元类，用于区分 Windows 和 Linux 的配置
class HMIServerConfig:
def __init__(self):
if IS_WINDOWS:
self._config_path = r"Software\XYZ Robotics\xyz_max_hmi_server"
else:
self._config_path = os.path.expanduser(
r"~/.config/XYZ Robotics/xyz_max_hmi_server.conf"
)
os.makedirs(os.path.dirname(self._config_path), exist_ok=True)
if not os.path.exists(self._config_path):
with open(self._config_path, "w", encoding="utf-8") as f:
f.write("[General]\n")
self._config = configparser.ConfigParser()
self._config.read(self._config_path)
def set(self, key: str, value: str) -> None:
if IS_WINDOWS:
write_hkey(key, value, self._config_path)
else:
if not self._config.has_section("General"):
self._config.add_section("General")
self._config.set("General", key, value)
with open(self._config_path, "w", encoding="utf-8") as f:
self._config.write(f)
def get(self, key: str) -> Optional[str]:
if IS_WINDOWS:
return read_hkey(key, self._config_path)
else:
return self._config["General"].get(key, None)
# def show(self):
# if IS_WINDOWS:
# import winreg
# with winreg.OpenKey(
# winreg.HKEY_CURRENT_USER, self._config_path
# ) as hkey:
# for i in range(winreg.QueryInfoKey(hkey)[1]):
# print(winreg.EnumValue(hkey, i))
# else:
# print(self._config_path)
# print(self._config.sections())
# print(self._config.items("General"))
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\subapp.py | """Subapp reload module."""
import importlib
import sys
import threading
import pydantic
from loguru import logger
from starlette.routing import Mount
from watchdog.events import FileSystemEventHandler
from watchdog.observers import Observer
from watchdog.utils.dirsnapshot import DirectorySnapshot, DirectorySnapshotDiff
from xyz_max_hmi_server import cached_app
from xyz_max_hmi_server.config import settings
from xyz_max_hmi_server.modules.monitor.dispatch import dispatcher
from xyz_max_hmi_server.modules.monitor.listener import Listener
def shutdown_listener():
"""关闭所有的监听器"""
Listener.unregister_all()
dispatcher.listener_manager.restart_all_listeners()
def reload_subapp(app):
"""重新挂载 WCS Adaptor"""
def _reload_modules():
reload_modules = {}
for name, module in sys.modules.items():
if module is None:
continue
if not hasattr(module, "__file__"):
continue
if name.startswith("wcs_adaptor"):
reload_modules[name] = module
# pydantic 会缓存 class_validators，需要清除
should_delete_class_validators = []
for name in pydantic.class_validators._FUNCS:
if "wcs_adaptor" in name:
should_delete_class_validators.append(name)
for name in should_delete_class_validators:
pydantic.class_validators._FUNCS.remove(name)
for _, module in reload_modules.items():
try:
importlib.reload(module)
except SyntaxError as e:
logger.error(f"重载模块 {module.__name__} 时发生语法错误: {e}")
_reload_modules()
def _remount():
# 删除已经挂载的 WCS Adaptor
for index, route in enumerate(app.routes):
if isinstance(route, Mount):
del app.routes[index]
break
# 重新挂载 WCS Adaptor
subapp = importlib.import_module("wcs_adaptor.main").app
app.mount("/adaptor", subapp, name="WCS Adaptor")
_remount()
_remount()
def reload():
"""重载插件"""
app = cached_app()
if app is None:
raise RuntimeError("app is None")
try:
shutdown_listener()
reload_subapp(app)
settings.reload() # type: ignore
except Exception as e:
logger.error(f"重载发生错误: {e}")
else:
logger.success("重载 WCS Adaptor 完成")
class FileModifiedEventHandler(FileSystemEventHandler):
"""文件变更事件处理器"""
def __init__(self, path: str): # noqa: D107
self.path = path
self.snapshot = DirectorySnapshot(path)
self.timer = None
def check_snapshot(self):
"""更新快照"""
new_snapshot = DirectorySnapshot(self.path)
diff = DirectorySnapshotDiff(self.snapshot, new_snapshot)
self.timer = None
self.snapshot = new_snapshot
should_reload_files = set()
for file_path in diff.files_modified:
if file_path.endswith(".py") or file_path.endswith(".yaml"):
should_reload_files.add(file_path)
for file_path in should_reload_files:
logger.warning(f"文件已变更: {file_path}")
if should_reload_files:
reload()
def on_any_event(self, _): # noqa: D102
if self.timer:
self.timer.cancel()
self.timer = threading.Timer(0.2, self.check_snapshot)
self.timer.start()
def watcher():
"""启动文件监控"""
observer = Observer()
path = settings.project_dir.as_posix()
observer.schedule(
FileModifiedEventHandler(path),
path=path,
recursive=True,
)
observer.daemon = True
observer.setName("WCSAdaptorWatcher")
observer.start()
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\utils.py | """Utils"""
import asyncio
import contextlib
import enum
import os
import subprocess
from concurrent.futures import Future
from datetime import date, datetime
from functools import partial
from os import PathLike
from pathlib import Path
from typing import Any, Union
import psutil
from fastapi.encoders import jsonable_encoder as _jsonable_encoder
from loguru import logger
from .studio_max import get_current_project_dir
@contextlib.contextmanager
def chdir(path: Union[str, PathLike]):
"""Change current working directory"""
cwd = os.getcwd()
os.chdir(path)
yield
os.chdir(cwd)
def run_coroutine(coro) -> Any:
"""Run coroutine on thread"""
return asyncio.run(coro)
def run_coroutine_in_current_thread(coro) -> Future:
"""Run coroutine in current thread
Example:
>>> future = run_coroutine_in_current_thread(coro)
>>> future.result()
Returns:
Future: Future object
"""
loop = asyncio.get_event_loop()
# PERF: 应该新开一个线程来执行，而不是在当前线程执行
# 目前在当前线程执行的方式，将回阻塞当前线程中的事件循环
return asyncio.run_coroutine_threadsafe(coro, loop)
def run_cmd(cmd: str, *args, **kwargs):
"""Run command"""
return os.system(cmd)
# NOTE: 由于 fastapi 的 jsonable_encoder 会将 datetime 转换为 str
# 因此需要自定义一个 来避免这种情况
jsonable_custom_encoder = partial(
_jsonable_encoder,
custom_encoder={
datetime: lambda dt: dt,
date: lambda d: d,
enum.Enum: lambda e: e,
},
)
def get_workdir() -> Path:
"""获取工作目录.
获取工作目录的优先级如下：
1. 环境变量 MAX_HMI_WORKDIR
2. Studio Max 工程目录
3. 当前目录
"""
workdir = os.getenv("MAX_HMI_WORKDIR", None)
if workdir is None:
workdir = get_current_project_dir()
if workdir:
workdir = workdir / "hmi"
if workdir is None:
workdir = os.getcwd()
return Path(workdir)
def get_studio_max_install_path() -> Path:
"""获取 Studio Max 安装目录.
current_file_path: ~/xyz-studio-max/lib/python/dist-packages/xyz_max_hmi_server/utils/utils.py
studio_max_root_dir: ~/xyz-studio-max
"""
current_file_path = Path(__file__)
return current_file_path.parents[5]
def kill_leftover_self_process():
"""杀掉自身残留的进程."""
# 获取所有进程列表
all_processes = psutil.process_iter()
current_pid = os.getpid()
def _kill(process, pid):
process.terminate()
process.wait()
logger.warning(f"已关闭残留进程: {pid}")
# 遍历进程列表
for process in all_processes:
# 判断待关闭的进程是否为当前进程
if process.pid == current_pid:
continue
killed_pid = process.pid
try:
# 获取进程的命令行参数
cmd = process.cmdline()
if os.name == "nt":
if len(cmd) >= 2 and cmd[0] == "python":
if "hmi_server.py" in cmd[-1]:
_kill(process, killed_pid)
else:
if cmd and cmd[0] == "xyz_max_hmi_server":
_kill(process, killed_pid)
except (
psutil.NoSuchProcess,
psutil.AccessDenied,
psutil.ZombieProcess,
):
# 捕获异常，继续遍历下一个进程
pass
def kill_process_on_port(port: int):
for conn in psutil.net_connections():
if conn.status == "LISTEN" and conn.laddr.port == port: # type: ignore
pid = conn.pid
break
else:
return
# 关闭进程
try:
process = psutil.Process(pid)
process.terminate()
logger.info(f"已关闭占用 {port} 端口的进程（PID={pid}）")
except psutil.NoSuchProcess:
logger.info(f"进程已经退出，PID={pid}")
except psutil.AccessDenied:
logger.info(f"没有足够的权限关闭进程，PID={pid}")
def start_nginx(start_path):
"""启动 Nginx 子进程"""
# error_log_path = get_log_path() / "nginx/error.log"
# if not error_log_path.exists():
# error_log_path.parent.mkdir(parents=True, exist_ok=True)
# error_log_path.touch()
if os.name == "nt":
if not (start_path / "nginx-win/nginx.exe").exists():
logger.warning("Nginx 未安装")
return
p = subprocess.Popen(
[
f"{start_path}/nginx-win/nginx.exe",
"-c",
f"{start_path}/nginx-win/conf/nginx.conf",
"-p",
f"{start_path}/nginx-win/",
# "-g",
# "access_log {}; error_log {};".format(
# (get_log_path() / "nginx/error.log").as_posix(),
# ),
],
creationflags=subprocess.CREATE_NEW_PROCESS_GROUP,
)
else:
if not (start_path / "nginx-linux/nginx").exists():
logger.warning("Nginx 未安装")
return
p = subprocess.Popen(
[
f"{start_path}/nginx-linux/nginx",
"-c",
f"{start_path}/nginx-linux/conf/nginx.conf",
"-p",
f"{start_path}/nginx-linux/",
# "-g",
# "access_log {}; error_log {};".format(
# (get_log_path() / "nginx/error.log").as_posix(),
# ),
],
preexec_fn=os.setsid,
)
try:
if p.wait(1):
raise RuntimeError("启动 Nginx 失败")
except subprocess.TimeoutExpired:
pass
return p
def kill_leftover_nginx():
"""杀掉残留的 nginx 进程."""
for proc in psutil.process_iter():
try:
pinfo = proc.as_dict(attrs=["pid", "name", "cmdline"])
if (
pinfo["name"] == "nginx.exe"
and len(pinfo["cmdline"]) > 0
and "nginx-win" in pinfo["cmdline"][0]
):
# kill
proc.kill()
elif (
pinfo["name"] == "nginx"
and len(pinfo["cmdline"]) > 0
and "nginx-linux" in pinfo["cmdline"][0]
):
proc.kill()
except (
psutil.NoSuchProcess,
psutil.AccessDenied,
psutil.ZombieProcess,
):
# 捕获异常，继续遍历下一个进程
pass
def compare_versions(version1, version2):
"""Compare two version strings version1 and version2.
version check rule:
1.3.4 < 1.5.1
1.3.4 < 1.5.1-pre.7+a81c57d1
1.4.0-pre.1+a81c57d1 < 1.5.0
1.5.0-pre.7+a81c57d1 < 1.5.0
1.5.0-pre.7+a81c57d1 < 1.5.0-pre.8+a81c57d1
"""
inf = float("inf")
def parse_version(version):
parts = version.split("-")
# 1.5.0 pre.1+a81c57
nums = list(map(int, parts[0].split(".")))
seq = inf
if len(parts) > 1:
seq = int(parts[1].split("+")[0].split(".")[-1])
return nums, seq
nums1, suffix1 = parse_version(version1)
nums2, suffix2 = parse_version(version2)
for i in range(len(nums1)):
if nums1[i] < nums2[i]:
return -1
elif nums1[i] > nums2[i]:
return 1
# 到这里，说明版本号是相等的
if suffix1 < suffix2:
return -1
elif suffix1 > suffix2:
return 1
else:
return 0
@contextlib.contextmanager
def timeit(name: str):
"""计时器上下文管理器"""
start = datetime.now()
yield
end = datetime.now()
logger.info(f"⚡{name} 耗时: {(end - start).total_seconds()}s")
| 0 |
xyz_max_hmi_server | repos\xyz_max_hmi_server\utils\vp.py | """VP 工具库"""
from typing import Dict # noqa: F401
from loguru import logger
from xyz_max_hmi_server import enums, signals
from xyz_max_hmi_server.exceptions import (
XYZGrpcError,
XYZNotFoundGrpcServiceError,
)
from xyz_max_hmi_server.modules.grpc.client.vp import VPClient
from xyz_max_hmi_server.modules.grpc.registry import registry
def check_status():
"""检查 VP 状态的装饰器"""
def wrapper(func):
def inner(*args, **kwargs):
r = func(*args, **kwargs)
vp_utils.check_status()
return r
return inner
return wrapper
# TODO: 移动到 modules 目录中
class VPUtils:
"""控制 VP 的工具类"""
def __init__(self) -> None: # noqa: D107
try:
self.service = registry.find("vp_global_service")
self.client = VPClient(self.service.get_channel())
except XYZNotFoundGrpcServiceError:
self.service = None
self.client = None
logger.warning("未找到 VP 服务.")
@check_status()
def run(self) -> None:
"""运行 VP 当前流图"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
self.client.run()
@check_status()
def stop(self) -> None:
"""停止 VP 当前流图"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
self.client.stop()
@check_status()
def pause(self) -> None:
"""暂停 VP 当前流图"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
self.client.pause()
@check_status()
def run_by_name(self, name: str):
"""运行 VP 指定流图
Args:
name(str): 流图名称， 即相对的流图文件路径，例如: "tasks/test.task"
"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
self.client.run_by_name(name)
@check_status()
def stop_by_name(self, name: str):
"""停止 VP 指定流图
Args:
name(str): 流图名称， 即相对的流图文件路径，例如: "tasks/test.task"
"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
self.client.stop_by_name(name)
def get_status(self) -> enums.VPStatus:
"""获取 VP 当前状态"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
data = self.client.get_status()
return enums.VPStatus(data["error_msg"])
def get_all_status(self) -> Dict[str, enums.VPStatus]:
"""获取 VP 当前所有状态"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
data = self.client.get_all_status()
return {k: enums.VPStatus(v) for k, v in data.items()}
def check_status(self) -> None:
"""检查 VP 状态"""
signals.vp_status_changed.send(self)
def is_all_stopped(self) -> bool:
"""检查所有流图是否都已经停止"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
data = self.client.get_all_status()
return all(v == enums.VPStatus.STOPPED.value for v in data.values())
def is_any_running(self) -> bool:
"""检查至少有一个流图在运行"""
if self.client is None:
raise XYZGrpcError("VP 服务不可用.")
data = self.client.get_all_status()
return any(v == enums.VPStatus.RUNNING.value for v in data.values())
vp_utils = VPUtils()
| 0 |
Subsets and Splits