sync

backend/app/schemas/analysis.py

@@ -18,7 +18,7 @@ class Analysis(AnalysisBase):
     id: int
 
     class Config:
-        orm_mode = True
+        from_attributes = True
 
 
 class AnalysisUpdate(BaseModel):

backend/app/schemas/plan.py

@@ -1,21 +1,43 @@
-from pydantic import BaseModel, Field
+from pydantic import BaseModel, Field, field_validator
 from datetime import datetime
-from typing import List, Optional
-from uuid import UUID
+from typing import List, Optional, Dict, Any
+from uuid import UUID, uuid4
+
+class TrainingGoals(BaseModel):
+    """Training goals for plan generation."""
+    primary_goal: str = Field(..., description="Primary training goal")
+    target_weekly_hours: int = Field(..., ge=3, le=20, description="Target hours per week")
+    fitness_level: str = Field(..., description="Current fitness level")
+    event_date: Optional[str] = Field(None, description="Target event date (YYYY-MM-DD)")
+    preferred_routes: List[int] = Field(default=[], description="Preferred route IDs")
+    avoid_days: List[str] = Field(default=[], description="Days to avoid training")
 
 class PlanBase(BaseModel):
-    jsonb_plan: dict = Field(..., description="Training plan data in JSONB format")
+    jsonb_plan: Dict[str, Any] = Field(..., description="Training plan data in JSONB format")
     version: int = Field(..., gt=0, description="Plan version number")
-    parent_plan_id: Optional[int] = Field(None, description="Parent plan ID for evolution tracking")
+    parent_plan_id: Optional[UUID] = Field(None, description="Parent plan ID for evolution tracking")
 
 class PlanCreate(PlanBase):
     pass
 
 class Plan(PlanBase):
-    id: int
-    created_at: datetime
-    analyses: List["Analysis"] = Field([], description="Analyses that created this plan version")
-    child_plans: List["Plan"] = Field([], description="Evolved versions of this plan")
+    id: UUID = Field(default_factory=uuid4)
+    created_at: datetime = Field(default_factory=datetime.utcnow)
+    updated_at: Optional[datetime] = Field(default=None)
 
-    class Config:
-        orm_mode = True
+    model_config = {"from_attributes": True}
+
+class PlanGenerationRequest(BaseModel):
+    """Request schema for plan generation."""
+    rule_ids: List[int] = Field(..., description="Rule set IDs to apply")
+    goals: TrainingGoals = Field(..., description="Training goals")
+    duration_weeks: int = Field(4, ge=1, le=20, description="Plan duration in weeks")
+    user_preferences: Optional[Dict[str, Any]] = Field(None, description="Additional preferences")
+    preferred_routes: List[int] = Field(default=[], description="Preferred route IDs")
+
+class PlanGenerationResponse(BaseModel):
+    """Response schema for plan generation."""
+    plan: Plan
+    generation_metadata: Dict[str, Any] = Field(..., description="Generation metadata")
+    
+    model_config = {"from_attributes": True}

backend/app/schemas/rule.py

@@ -1,17 +1,49 @@
-from pydantic import BaseModel
-from typing import Optional
+from pydantic import BaseModel, Field, field_validator
+from typing import Optional, Dict, Any, List
+from uuid import UUID
+from datetime import datetime
+
+class NaturalLanguageRuleRequest(BaseModel):
+    """Request schema for natural language rule parsing."""
+    natural_language_text: str = Field(
+        ...,
+        min_length=10,
+        max_length=5000,
+        description="Natural language rule description"
+    )
+    rule_name: str = Field(..., min_length=1, max_length=100, description="Rule set name")
+    
+    @field_validator('natural_language_text')
+    @classmethod
+    def validate_text_content(cls, v):
+        required_keywords = ['ride', 'week', 'hour', 'day', 'rest', 'training']
+        if not any(keyword in v.lower() for keyword in required_keywords):
+            raise ValueError("Text must contain training-related keywords")
+        return v
+
+class ParsedRuleResponse(BaseModel):
+    """Response schema for parsed rules."""
+    parsed_rules: Dict[str, Any] = Field(..., description="Structured rule data")
+    confidence_score: Optional[float] = Field(None, ge=0.0, le=1.0, description="Parsing confidence")
+    suggestions: List[str] = Field(default=[], description="Improvement suggestions")
+    validation_errors: List[str] = Field(default=[], description="Validation errors")
+    rule_name: str = Field(..., description="Rule set name")
 
 class RuleBase(BaseModel):
-    name: str
-    description: Optional[str] = None
-    condition: str
-    priority: int = 0
+    """Base rule schema."""
+    name: str = Field(..., min_length=1, max_length=100)
+    description: Optional[str] = Field(None, max_length=500)
+    user_defined: bool = Field(True, description="Whether rule is user-defined")
+    rule_text: str = Field(..., min_length=10, description="Plaintext rule description")
+    version: int = Field(1, ge=1, description="Rule version")
+    parent_rule_id: Optional[UUID] = Field(None, description="Parent rule for versioning")
 
 class RuleCreate(RuleBase):
     pass
 
 class Rule(RuleBase):
-    id: str
+    id: UUID
+    created_at: datetime
+    updated_at: datetime
 
-    class Config:
-        orm_mode = True
+    model_config = {"from_attributes": True}