wehub-resource-sync
279 lines
9.4 KiB
Python
279 lines
9.4 KiB
Python
from typing import Dict, List, Optional
|
|
|
|
from fastapi import APIRouter, HTTPException
|
|
from loguru import logger
|
|
from pydantic import BaseModel, Field
|
|
|
|
from open_notebook.exceptions import InvalidInputError, OpenNotebookError
|
|
from open_notebook.podcasts.models import EpisodeProfile, SpeakerProfile
|
|
|
|
router = APIRouter()
|
|
|
|
|
|
class EpisodeProfileResponse(BaseModel):
|
|
id: str
|
|
name: str
|
|
description: str
|
|
speaker_config: Optional[str] = Field(
|
|
None, description="speaker_profile record ID (null when orphaned)"
|
|
)
|
|
speaker_config_name: Optional[str] = Field(
|
|
None, description="Resolved speaker profile name (for display)"
|
|
)
|
|
outline_llm: Optional[str] = None
|
|
transcript_llm: Optional[str] = None
|
|
language: Optional[str] = None
|
|
default_briefing: str
|
|
num_segments: int
|
|
max_tokens: Optional[int] = None
|
|
|
|
|
|
async def _speaker_names_by_id() -> Dict[str, str]:
|
|
"""Map speaker_profile record ID -> name for list serialization."""
|
|
speakers = await SpeakerProfile.get_all()
|
|
return {str(speaker.id): speaker.name for speaker in speakers}
|
|
|
|
|
|
async def _speaker_name_for(speaker_config: Optional[str]) -> Optional[str]:
|
|
"""Resolve one profile's speaker_config record ID to the speaker name.
|
|
|
|
Returns None for a missing or dangling reference - the frontend renders
|
|
that as "needs setup"."""
|
|
if not speaker_config:
|
|
return None
|
|
speaker = await SpeakerProfile.resolve(speaker_config)
|
|
return speaker.name if speaker else None
|
|
|
|
|
|
def _profile_to_response(
|
|
profile: EpisodeProfile, speaker_name: Optional[str]
|
|
) -> EpisodeProfileResponse:
|
|
return EpisodeProfileResponse(
|
|
id=str(profile.id),
|
|
name=profile.name,
|
|
description=profile.description or "",
|
|
speaker_config=profile.speaker_config,
|
|
speaker_config_name=speaker_name,
|
|
outline_llm=profile.outline_llm,
|
|
transcript_llm=profile.transcript_llm,
|
|
language=profile.language,
|
|
default_briefing=profile.default_briefing,
|
|
num_segments=profile.num_segments,
|
|
max_tokens=profile.max_tokens,
|
|
)
|
|
|
|
|
|
async def _resolve_speaker_config(value: str) -> SpeakerProfile:
|
|
"""Resolve an incoming speaker_config (record ID, or name for backward
|
|
compatibility) to the referenced SpeakerProfile."""
|
|
speaker = await SpeakerProfile.resolve(value)
|
|
if not speaker:
|
|
raise InvalidInputError(f"Speaker profile '{value}' not found")
|
|
return speaker
|
|
|
|
|
|
@router.get("/episode-profiles", response_model=List[EpisodeProfileResponse])
|
|
async def list_episode_profiles():
|
|
"""List all available episode profiles"""
|
|
try:
|
|
profiles = await EpisodeProfile.get_all(order_by="name asc")
|
|
speaker_names = await _speaker_names_by_id()
|
|
return [
|
|
_profile_to_response(
|
|
p, speaker_names.get(p.speaker_config) if p.speaker_config else None
|
|
)
|
|
for p in profiles
|
|
]
|
|
except HTTPException:
|
|
raise
|
|
except OpenNotebookError:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Failed to fetch episode profiles: {e}")
|
|
raise HTTPException(
|
|
status_code=500, detail="Failed to fetch episode profiles"
|
|
)
|
|
|
|
|
|
@router.get("/episode-profiles/{profile_name}", response_model=EpisodeProfileResponse)
|
|
async def get_episode_profile(profile_name: str):
|
|
"""Get a specific episode profile by name"""
|
|
try:
|
|
profile = await EpisodeProfile.get_by_name(profile_name)
|
|
|
|
if not profile:
|
|
raise HTTPException(
|
|
status_code=404, detail=f"Episode profile '{profile_name}' not found"
|
|
)
|
|
|
|
return _profile_to_response(
|
|
profile, await _speaker_name_for(profile.speaker_config)
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except OpenNotebookError:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Failed to fetch episode profile '{profile_name}': {e}")
|
|
raise HTTPException(
|
|
status_code=500, detail="Failed to fetch episode profile"
|
|
)
|
|
|
|
|
|
class EpisodeProfileCreate(BaseModel):
|
|
name: str = Field(..., description="Unique profile name")
|
|
description: str = Field("", description="Profile description")
|
|
speaker_config: str = Field(
|
|
...,
|
|
description=(
|
|
"speaker_profile record ID (a profile name is also accepted "
|
|
"for backward compatibility)"
|
|
),
|
|
)
|
|
outline_llm: Optional[str] = Field(None, description="Model record ID for outline")
|
|
transcript_llm: Optional[str] = Field(
|
|
None, description="Model record ID for transcript"
|
|
)
|
|
language: Optional[str] = Field(None, description="Podcast language code")
|
|
default_briefing: str = Field(..., description="Default briefing template")
|
|
num_segments: int = Field(default=5, description="Number of podcast segments")
|
|
max_tokens: Optional[int] = Field(
|
|
None,
|
|
description="Max output tokens for outline/transcript generation",
|
|
)
|
|
|
|
|
|
@router.post("/episode-profiles", response_model=EpisodeProfileResponse)
|
|
async def create_episode_profile(profile_data: EpisodeProfileCreate):
|
|
"""Create a new episode profile"""
|
|
try:
|
|
speaker = await _resolve_speaker_config(profile_data.speaker_config)
|
|
profile = EpisodeProfile(
|
|
name=profile_data.name,
|
|
description=profile_data.description,
|
|
speaker_config=str(speaker.id),
|
|
outline_llm=profile_data.outline_llm,
|
|
transcript_llm=profile_data.transcript_llm,
|
|
language=profile_data.language,
|
|
default_briefing=profile_data.default_briefing,
|
|
num_segments=profile_data.num_segments,
|
|
max_tokens=profile_data.max_tokens,
|
|
)
|
|
|
|
await profile.save()
|
|
return _profile_to_response(profile, speaker.name)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except OpenNotebookError:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Failed to create episode profile: {e}")
|
|
raise HTTPException(
|
|
status_code=500, detail="Failed to create episode profile"
|
|
)
|
|
|
|
|
|
@router.put("/episode-profiles/{profile_id}", response_model=EpisodeProfileResponse)
|
|
async def update_episode_profile(profile_id: str, profile_data: EpisodeProfileCreate):
|
|
"""Update an existing episode profile"""
|
|
try:
|
|
profile = await EpisodeProfile.get(profile_id)
|
|
|
|
if not profile:
|
|
raise HTTPException(
|
|
status_code=404, detail=f"Episode profile '{profile_id}' not found"
|
|
)
|
|
|
|
update_data = profile_data.model_dump(exclude_unset=True)
|
|
speaker_name: Optional[str] = None
|
|
if "speaker_config" in update_data:
|
|
speaker = await _resolve_speaker_config(update_data["speaker_config"])
|
|
update_data["speaker_config"] = str(speaker.id)
|
|
speaker_name = speaker.name
|
|
for field, value in update_data.items():
|
|
setattr(profile, field, value)
|
|
|
|
await profile.save()
|
|
if speaker_name is None:
|
|
speaker_name = await _speaker_name_for(profile.speaker_config)
|
|
return _profile_to_response(profile, speaker_name)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except OpenNotebookError:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Failed to update episode profile: {e}")
|
|
raise HTTPException(
|
|
status_code=500, detail="Failed to update episode profile"
|
|
)
|
|
|
|
|
|
@router.delete("/episode-profiles/{profile_id}")
|
|
async def delete_episode_profile(profile_id: str):
|
|
"""Delete an episode profile"""
|
|
try:
|
|
profile = await EpisodeProfile.get(profile_id)
|
|
|
|
if not profile:
|
|
raise HTTPException(
|
|
status_code=404, detail=f"Episode profile '{profile_id}' not found"
|
|
)
|
|
|
|
await profile.delete()
|
|
|
|
return {"message": "Episode profile deleted successfully"}
|
|
|
|
except HTTPException:
|
|
raise
|
|
except OpenNotebookError:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Failed to delete episode profile: {e}")
|
|
raise HTTPException(
|
|
status_code=500, detail="Failed to delete episode profile"
|
|
)
|
|
|
|
|
|
@router.post(
|
|
"/episode-profiles/{profile_id}/duplicate", response_model=EpisodeProfileResponse
|
|
)
|
|
async def duplicate_episode_profile(profile_id: str):
|
|
"""Duplicate an episode profile"""
|
|
try:
|
|
original = await EpisodeProfile.get(profile_id)
|
|
|
|
if not original:
|
|
raise HTTPException(
|
|
status_code=404, detail=f"Episode profile '{profile_id}' not found"
|
|
)
|
|
|
|
duplicate = EpisodeProfile(
|
|
name=f"{original.name} - Copy",
|
|
description=original.description,
|
|
speaker_config=original.speaker_config,
|
|
outline_llm=original.outline_llm,
|
|
transcript_llm=original.transcript_llm,
|
|
language=original.language,
|
|
default_briefing=original.default_briefing,
|
|
num_segments=original.num_segments,
|
|
max_tokens=original.max_tokens,
|
|
)
|
|
|
|
await duplicate.save()
|
|
return _profile_to_response(
|
|
duplicate, await _speaker_name_for(duplicate.speaker_config)
|
|
)
|
|
|
|
except HTTPException:
|
|
raise
|
|
except OpenNotebookError:
|
|
raise
|
|
except Exception as e:
|
|
logger.error(f"Failed to duplicate episode profile: {e}")
|
|
raise HTTPException(
|
|
status_code=500, detail="Failed to duplicate episode profile"
|
|
)
|