fix: improve error handling and logging in YouTubeAnalysisService

app/services/youtube_analysis.py

@@ -15,7 +15,7 @@ from typing import List
 from .external_clients import ClientResponse, MusicAIDetectorClient, SesAnaliziClient
 from .preview_model import create_preview_result
 from .url_parser import parse_youtube_url
-from .youtube_downloader import YouTubeDownloader
+from .youtube_downloader import YouTubeDownloadError, YouTubeDownloader
 from .logging_config import get_logger
 from ..schemas import AnalysisSummary, ServiceResult, YouTubeAnalyzeResponse, YouTubeSource
 
@@ -23,6 +23,16 @@ from ..schemas import AnalysisSummary, ServiceResult, YouTubeAnalyzeResponse, Yo
 logger = get_logger(__name__)
 
 
+def _unique_strings(values: List[str]) -> List[str]:
+    return list(dict.fromkeys(values))
+
+
+def _download_error_codes(error_code: str) -> List[str]:
+    if error_code == "youtube_authentication_required":
+        return ["youtube_authentication_required", "youtube_analysis_failed"]
+    return ["youtube_analysis_failed"]
+
+
 def _preview_summary(video_id: str, warnings: List[str]) -> AnalysisSummary:
     result = create_preview_result(video_id, warnings)
     
@@ -65,11 +75,34 @@ class YouTubeAnalysisService:
             try:
                 download_result = downloader.download(parsed.normalized_url, parsed.video_id)
                 logger.info(f"Download completed in {time.monotonic() - start_download:.2f}s")
+            except YouTubeDownloadError as exc:
+                logger.error(f"Download failed ({exc.error_code}): {exc}")
+                warnings.extend(exc.warnings)
+                errors.extend(_download_error_codes(exc.error_code))
+                timings["total_sec"] = round(time.monotonic() - start_total, 4)
+                summary = _preview_summary(parsed.video_id, _unique_strings(warnings))
+                source = YouTubeSource(
+                    url=url,
+                    normalized_url=parsed.normalized_url,
+                    video_id=parsed.video_id,
+                    start_time_sec=parsed.start_time_sec,
+                )
+                return YouTubeAnalyzeResponse(
+                    request_id=request_id,
+                    status="partial",
+                    source=source,
+                    summary=summary,
+                    music_ai=ServiceResult(available=False, response=None, error=exc.error_code),
+                    ses_analizi=ServiceResult(available=False, response=None, error=exc.error_code),
+                    warnings=_unique_strings(warnings),
+                    errors=_unique_strings(errors),
+                    timings=timings,
+                )
             except Exception as exc:
                 logger.error(f"Download failed: {exc}")
-                errors.append(f"download_failed: {exc}")
+                errors.append("youtube_analysis_failed")
                 timings["total_sec"] = round(time.monotonic() - start_total, 4)
-                summary = _preview_summary(parsed.video_id, warnings)
+                summary = _preview_summary(parsed.video_id, _unique_strings(warnings))
                 source = YouTubeSource(
                     url=url,
                     normalized_url=parsed.normalized_url,
@@ -83,8 +116,8 @@ class YouTubeAnalysisService:
                     summary=summary,
                     music_ai=ServiceResult(available=False, response=None, error="download_failed"),
                     ses_analizi=ServiceResult(available=False, response=None, error="download_failed"),
-                    warnings=warnings,
-                    errors=errors,
+                    warnings=_unique_strings(warnings),
+                    errors=_unique_strings(errors),
                     timings=timings,
                 )
 
@@ -143,6 +176,7 @@ class YouTubeAnalysisService:
         elif ses_result.error:
             warnings.append("ses_analizi_failed")
 
+        warnings = _unique_strings(warnings)
         summary = self._build_summary(music_ai_result, ses_result, parsed.video_id, warnings)
         timings["total_sec"] = round(time.monotonic() - start_total, 4)
         
@@ -153,6 +187,7 @@ class YouTubeAnalysisService:
         if ses_result.error and ses_result.error not in {"ses_analizi_not_configured", "ses_analizi_unsupported_format"}:
             errors.append(ses_result.error)
 
+        errors = _unique_strings(errors)
         status = "ok" if not errors else "partial"
 
         source = YouTubeSource(