Coverage for src/robot_dispatch/api/schemas.py: 99%
98 statements
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
« prev ^ index » next coverage.py v7.17.2, created at 2026-11-07 17:18 +0000
1from __future__ import annotations
3from datetime import datetime
4from typing import Any
5from uuid import UUID
7from pydantic import BaseModel, ConfigDict, Field, field_validator
9from robot_dispatch.domain.enums import TaskStatus
12class TaskCreateRequest(BaseModel):
13 type: str = Field(min_length=1, max_length=64, examples=["delivery"])
14 payload: dict[str, Any] = Field(default_factory=dict)
15 priority: int = Field(default=100, ge=0, le=1000, description="Higher value is dispatched first")
16 external_id: str | None = Field(
17 default=None,
18 max_length=128,
19 description="Caller-side idempotency key (or send the Idempotency-Key header)",
20 )
21 max_attempts: int | None = Field(default=None, ge=1, le=10)
22 timeout_seconds: int | None = Field(
23 default=None, ge=1, le=86_400, description="Lease duration for a single attempt"
24 )
26 @field_validator("type")
27 @classmethod
28 def _normalize_type(cls, value: str) -> str:
29 normalized = value.strip().lower()
30 if not normalized:
31 raise ValueError("type must not be blank")
32 return normalized
34 @field_validator("external_id")
35 @classmethod
36 def _strip_external_id(cls, value: str | None) -> str | None:
37 if value is None:
38 return None
39 value = value.strip()
40 return value or None
43class TaskResponse(BaseModel):
44 model_config = ConfigDict(from_attributes=True)
46 id: UUID
47 type: str
48 status: TaskStatus
49 priority: int
50 payload: dict[str, Any]
51 external_id: str | None
52 robot_id: UUID | None
53 command_id: UUID | None
54 attempts: int
55 max_attempts: int
56 timeout_seconds: int
57 available_at: datetime
58 lease_expires_at: datetime | None
59 started_at: datetime | None
60 finished_at: datetime | None
61 last_error: str | None
62 result: dict[str, Any] | None
63 created_at: datetime
64 updated_at: datetime
65 version: int
68class TaskListResponse(BaseModel):
69 items: list[TaskResponse]
70 limit: int
71 offset: int
74class TaskEventResponse(BaseModel):
75 model_config = ConfigDict(from_attributes=True)
77 id: UUID
78 task_id: UUID
79 kind: str
80 from_status: str | None
81 to_status: str | None
82 robot_id: UUID | None
83 message: str | None
84 payload: dict[str, Any]
85 created_at: datetime
88class RobotRegisterRequest(BaseModel):
89 name: str = Field(min_length=1, max_length=128, examples=["robot-1"])
90 namespace: str = Field(min_length=1, max_length=128, examples=["/robot1"])
91 capabilities: list[str] = Field(
92 default_factory=lambda: ["delivery"],
93 description="Task types this robot can execute",
94 )
96 @field_validator("capabilities")
97 @classmethod
98 def _normalize_capabilities(cls, value: list[str]) -> list[str]:
99 cleaned = sorted({item.strip().lower() for item in value if item.strip()})
100 if not cleaned:
101 raise ValueError("at least one capability is required")
102 return cleaned
105class RobotResponse(BaseModel):
106 id: UUID
107 name: str
108 namespace: str
109 status: str
110 capabilities: list[str]
111 last_seen_at: datetime | None
112 current_task_id: UUID | None
113 created_at: datetime
114 updated_at: datetime
116 @classmethod
117 def from_robot(cls, robot) -> RobotResponse:
118 return cls(
119 id=robot.id,
120 name=robot.name,
121 namespace=robot.namespace,
122 status=robot.status,
123 capabilities=robot.capability_names,
124 last_seen_at=robot.last_seen_at,
125 current_task_id=robot.current_task_id,
126 created_at=robot.created_at,
127 updated_at=robot.updated_at,
128 )
131class RobotListResponse(BaseModel):
132 items: list[RobotResponse]
135class StatsResponse(BaseModel):
136 tasks: dict[str, int]
137 task_total: int
138 robots: dict[str, int]
139 queues: dict[str, int | None]
142class HealthResponse(BaseModel):
143 status: str
144 checks: dict[str, str]