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

1from __future__ import annotations 

2 

3from datetime import datetime 

4from typing import Any 

5from uuid import UUID 

6 

7from pydantic import BaseModel, ConfigDict, Field, field_validator 

8 

9from robot_dispatch.domain.enums import TaskStatus 

10 

11 

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 ) 

25 

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 

33 

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 

41 

42 

43class TaskResponse(BaseModel): 

44 model_config = ConfigDict(from_attributes=True) 

45 

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 

66 

67 

68class TaskListResponse(BaseModel): 

69 items: list[TaskResponse] 

70 limit: int 

71 offset: int 

72 

73 

74class TaskEventResponse(BaseModel): 

75 model_config = ConfigDict(from_attributes=True) 

76 

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 

86 

87 

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 ) 

95 

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 

103 

104 

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 

115 

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 ) 

129 

130 

131class RobotListResponse(BaseModel): 

132 items: list[RobotResponse] 

133 

134 

135class StatsResponse(BaseModel): 

136 tasks: dict[str, int] 

137 task_total: int 

138 robots: dict[str, int] 

139 queues: dict[str, int | None] 

140 

141 

142class HealthResponse(BaseModel): 

143 status: str 

144 checks: dict[str, str]