syncing with old implementation

app/routers/analyze.py

@@ -3,7 +3,7 @@ from mediaunmasked.schemas.requests import AnalyzeRequest
 from mediaunmasked.schemas.responses import AnalyzeResponse
 from mediaunmasked.services.analyzer_service import AnalyzerService
 from mediaunmasked.scrapers.article_scraper import ArticleScraper # Assuming you have a scraper module
-from mediaunmasked.analyzers import scoring  # Assuming you have a scorer module
+from mediaunmasked.analyzers.scoring import MediaScorer  # Assuming you have a scorer module
 import logging
 
 logger = logging.getLogger(__name__)
@@ -11,6 +11,7 @@ logger = logging.getLogger(__name__)
 router = APIRouter(tags=["analysis"])
 
 scraper = ArticleScraper()
+scorer = MediaScorer()
 
 @router.post("/analyze", response_model=AnalyzeResponse)
 async def analyze_content(request: AnalyzeRequest):
@@ -24,7 +25,7 @@ async def analyze_content(request: AnalyzeRequest):
             )
 
         # Perform the analysis (like your old code)
-        analysis = scoring.calculate_media_score(
+        analysis = scorer.calculate_media_score(
             article["headline"],
             article["content"]
         )

mediaunmasked/schemas/requests.py

@@ -1,5 +1,30 @@
-from pydantic import BaseModel
+from pydantic import BaseModel, HttpUrl
+from typing import Dict, Any, List
 
 class AnalyzeRequest(BaseModel):
+    url: HttpUrl
+    
+    def get_url_str(self) -> str:
+        # Convert HttpUrl to string safely
+        return str(self.url)
+
+class MediaScoreDetails(BaseModel):
+    headline_analysis: Dict[str, Any]
+    sentiment_analysis: Dict[str, Any]
+    bias_analysis: Dict[str, Any]
+    evidence_analysis: Dict[str, Any]
+
+class MediaScore(BaseModel):
+    media_unmasked_score: float
+    rating: str
+    details: MediaScoreDetails
+
+class AnalysisResponse(BaseModel):
     headline: str
-    content: str 
+    content: str
+    sentiment: str
+    bias: str
+    bias_score: float
+    bias_percentage: float
+    flagged_phrases: List[str]
+    media_score: MediaScore

mediaunmasked/services/analyzer_service.py

@@ -1,4 +1,13 @@
 from mediaunmasked.analyzers.headline_analyzer import HeadlineAnalyzer
+from mediaunmasked.schemas.requests import AnalyzeRequest, AnalysisResponse
+from fastapi import HTTPException
+from mediaunmasked.scrapers.article_scraper import ArticleScraper
+from mediaunmasked.analyzers.scoring import MediaScorer
+import logging
+
+logger = logging.getLogger(__name__)
+scraper = ArticleScraper()
+scorer = MediaScorer()
 
 class AnalyzerService:
     def __init__(self):
@@ -6,4 +15,68 @@ class AnalyzerService:
 
     async def analyze_content(self, headline: str, content: str):
         result = self.headline_analyzer.analyze(headline, content)
-        return result 
+        return result 
+
+    async def analyze_url(self, request: AnalyzeRequest) -> AnalysisResponse:
+        """
+        Analyze an article for bias, sentiment, and credibility.
+        """
+        try:
+            logger.info(f"Analyzing article: {request.url}")
+            
+            # Scrape article
+            article = await scraper.scrape_article(request.get_url_str())
+            if not article:
+                raise HTTPException(
+                    status_code=400,
+                    detail="Failed to scrape article content"
+                )
+            
+            # Analyze content
+            analysis = scorer.calculate_media_score(
+                article["headline"],
+                article["content"]
+            )
+            
+            # Construct response
+            response_dict = {
+                "headline": str(article['headline']),
+                "content": str(article['content']),
+                "sentiment": str(analysis['details']['sentiment_analysis']['sentiment']),
+                "bias": str(analysis['details']['bias_analysis']['bias']),
+                "bias_score": float(analysis['details']['bias_analysis']['bias_score']),
+                "bias_percentage": float(analysis['details']['bias_analysis']['bias_percentage']),
+                "flagged_phrases": list(analysis['details']['sentiment_analysis']['flagged_phrases']),
+                "media_score": {
+                    "media_unmasked_score": float(analysis['media_unmasked_score']),
+                    "rating": str(analysis['rating']),
+                    "details": {
+                        "headline_analysis": {
+                            "headline_vs_content_score": float(analysis['details']['headline_analysis']['headline_vs_content_score']),
+                            "contradictory_phrases": analysis['details']['headline_analysis'].get('contradictory_phrases', [])
+                        },
+                        "sentiment_analysis": {
+                            "sentiment": str(analysis['details']['sentiment_analysis']['sentiment']),
+                            "manipulation_score": float(analysis['details']['sentiment_analysis']['manipulation_score']),
+                            "flagged_phrases": list(analysis['details']['sentiment_analysis']['flagged_phrases'])
+                        },
+                        "bias_analysis": {
+                            "bias": str(analysis['details']['bias_analysis']['bias']),
+                            "bias_score": float(analysis['details']['bias_analysis']['bias_score']),
+                            "bias_percentage": float(analysis['details']['bias_analysis']['bias_percentage'])
+                        },
+                        "evidence_analysis": {
+                            "evidence_based_score": float(analysis['details']['evidence_analysis']['evidence_based_score'])
+                        }
+                    }
+                }
+            }
+            
+            return AnalysisResponse.parse_obj(response_dict)
+            
+        except Exception as e:
+            logger.error(f"Analysis failed: {str(e)}", exc_info=True)
+            raise HTTPException(
+                status_code=500,
+                detail=f"Analysis failed: {str(e)}"
+            )