Implement OAuth2 authentication for Google PageSpeed Insights API

- Added Google Service Account authentication with OAuth2
- Created comprehensive setup instructions in UI and README
- Implemented fallback to demo mode when not configured
- Added proper error handling and authentication validation
- Updated dependencies for Google auth libraries
- App now supports both real API data and demo mode seamlessly

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

README.md

@@ -21,9 +21,31 @@ Compare análises do PageSpeed Insights para monitorar melhorias em Core Web Vit
 - 🤖 Análise inteligente com OpenAI GPT-o1
 - 📈 Visualização de melhorias e regressões
 - 💡 Recomendações priorizadas
+- 🔐 Autenticação OAuth2 com Google PageSpeed Insights API
+- 🔄 Modo demo quando não configurado
+
+## Configuração para Dados Reais
+
+### 1. Criar Projeto Google Cloud
+1. Acesse [Google Cloud Console](https://console.cloud.google.com/)
+2. Crie um novo projeto
+3. Ative a **PageSpeed Insights API**
+
+### 2. Criar Service Account
+1. Vá para **IAM & Admin** → **Service Accounts**
+2. Clique em **Create Service Account**
+3. Conceda papel **Viewer** ou **Editor**
+4. Baixe a chave JSON
+
+### 3. Configurar no Hugging Face Space
+1. **Settings** → **Variables and secrets**
+2. Adicione:
+   - `GOOGLE_SERVICE_ACCOUNT_JSON`: JSON completo da service account
+   - `OPENAI_API_KEY`: Sua chave OpenAI (opcional)
+3. Reinicie o Space
 
 ## Como usar
 
-1. Configure sua `OPENAI_API_KEY` nos Settings do Space
-2. Cole duas URLs de análises do PageSpeed Insights
-3. Compare e receba análise detalhada
+1. Cole duas URLs de análises do PageSpeed Insights
+2. Compare e receba análise detalhada
+3. Se não configurado, funciona em modo demo

google_auth.py

@@ -0,0 +1,107 @@
+"""Google OAuth2 and Service Account authentication for PageSpeed Insights API."""
+import json
+import os
+from typing import Optional
+from google.auth.transport.requests import Request
+from google.oauth2 import service_account
+import requests
+
+
+class GoogleAuthenticator:
+    """Handles Google API authentication using service account credentials."""
+    
+    def __init__(self):
+        self.credentials = None
+        self.setup_credentials()
+    
+    def setup_credentials(self):
+        """Setup Google service account credentials from environment variables."""
+        try:
+            # Try to get service account JSON from environment variable
+            service_account_json = os.environ.get('GOOGLE_SERVICE_ACCOUNT_JSON')
+            
+            if service_account_json:
+                # Parse the JSON string
+                service_account_info = json.loads(service_account_json)
+                
+                # Create credentials from service account info
+                self.credentials = service_account.Credentials.from_service_account_info(
+                    service_account_info,
+                    scopes=['https://www.googleapis.com/auth/cloud-platform']
+                )
+                
+                # Refresh the credentials to get access token
+                self.credentials.refresh(Request())
+                
+            else:
+                print("⚠️ GOOGLE_SERVICE_ACCOUNT_JSON não encontrado nas variáveis de ambiente")
+                
+        except Exception as e:
+            print(f"❌ Erro ao configurar credenciais do Google: {str(e)}")
+            self.credentials = None
+    
+    def get_access_token(self) -> Optional[str]:
+        """Get a valid access token for Google APIs."""
+        if not self.credentials:
+            return None
+            
+        try:
+            # Refresh token if needed
+            if not self.credentials.valid:
+                self.credentials.refresh(Request())
+            
+            return self.credentials.token
+            
+        except Exception as e:
+            print(f"❌ Erro ao obter token de acesso: {str(e)}")
+            return None
+    
+    def is_authenticated(self) -> bool:
+        """Check if we have valid authentication."""
+        return self.credentials is not None and self.credentials.valid
+
+
+class PageSpeedAPI:
+    """PageSpeed Insights API client with OAuth2 authentication."""
+    
+    def __init__(self):
+        self.authenticator = GoogleAuthenticator()
+        self.base_url = "https://www.googleapis.com/pagespeedonline/v5/runPagespeed"
+    
+    def analyze_url(self, url: str, strategy: str = 'mobile') -> Optional[dict]:
+        """Analyze a URL using PageSpeed Insights API with OAuth2."""
+        if not self.authenticator.is_authenticated():
+            raise ValueError("Google authentication not configured. Please set up service account credentials.")
+        
+        access_token = self.authenticator.get_access_token()
+        if not access_token:
+            raise ValueError("Could not obtain valid access token")
+        
+        try:
+            headers = {
+                'Authorization': f'Bearer {access_token}',
+                'Content-Type': 'application/json'
+            }
+            
+            params = {
+                'url': url,
+                'strategy': strategy,
+                'category': ['performance', 'accessibility', 'best-practices', 'seo']
+            }
+            
+            response = requests.get(
+                self.base_url,
+                headers=headers,
+                params=params,
+                timeout=60
+            )
+            
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.RequestException as e:
+            raise Exception(f"Error calling PageSpeed API: {str(e)}")
+    
+    def is_available(self) -> bool:
+        """Check if the PageSpeed API is available with current authentication."""
+        return self.authenticator.is_authenticated()

pagespeed_client.py

@@ -1,22 +1,18 @@
-"""Client for PageSpeed Insights web scraping."""
+"""Client for PageSpeed Insights API with OAuth2 authentication."""
 import requests
 import json
-import re
-from urllib.parse import urlparse, parse_qs, quote
+from urllib.parse import urlparse, parse_qs
 from typing import Optional
-from bs4 import BeautifulSoup
 
 from models import PageSpeedData
+from google_auth import PageSpeedAPI
 
 
 class PageSpeedClient:
-    """Client for scraping PageSpeed Insights web interface."""
+    """Client for PageSpeed Insights API with OAuth2 authentication."""
     def __init__(self):
-        self.session = requests.Session()
-        self.session.headers.update({
-            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
-        })
-        # No API key validation needed for web scraping
+        self.api_client = PageSpeedAPI()
+        self.use_mock_data = not self.api_client.is_available()
     
     def extract_pagespeed_data(self, report_url: str) -> Optional[PageSpeedData]:
         """Extract PageSpeed data from a PageSpeed Insights report URL."""
@@ -25,7 +21,13 @@ class PageSpeedClient:
         
         try:
             site_url, strategy = self._parse_report_url(report_url)
-            lighthouse_data = self._get_lighthouse_data(site_url, strategy)
+            
+            if self.use_mock_data:
+                # Use mock data if OAuth2 not configured
+                lighthouse_data = self._create_mock_lighthouse_data(site_url, strategy)
+            else:
+                # Use real API with OAuth2
+                lighthouse_data = self._get_real_lighthouse_data(site_url, strategy)
             
             if not lighthouse_data:
                 raise ValueError("Dados do Lighthouse não encontrados")
@@ -54,21 +56,17 @@ class PageSpeedClient:
         
         return site_url, strategy
     
-    def _get_lighthouse_data(self, site_url: str, strategy: str) -> Optional[dict]:
-        """Get Lighthouse data from an existing PageSpeed report URL."""
+    def _get_real_lighthouse_data(self, site_url: str, strategy: str) -> Optional[dict]:
+        """Get real Lighthouse data using OAuth2 authenticated API."""
         try:
-            # For this demo, we'll create mock data based on the URL and strategy
-            # In a real implementation, you would need to:
-            # 1. Extract data from the original report URL
-            # 2. Use a different API service
-            # 3. Or implement proper OAuth2 authentication
-            
-            # Create realistic mock data for demonstration
-            mock_data = self._create_mock_lighthouse_data(site_url, strategy)
-            return mock_data
-            
+            response = self.api_client.analyze_url(site_url, strategy)
+            return response.get('lighthouseResult')
         except Exception as e:
-            raise Exception(f"Erro ao obter dados do PageSpeed: {str(e)}")
+            raise Exception(f"Erro ao obter dados do PageSpeed API: {str(e)}")
+    
+    def is_using_real_data(self) -> bool:
+        """Check if using real API data or mock data."""
+        return not self.use_mock_data
     
     def _create_mock_lighthouse_data(self, site_url: str, strategy: str) -> dict:
         """Create mock Lighthouse data for demonstration purposes."""

requirements.txt

@@ -3,4 +3,7 @@ requests>=2.31.0
 beautifulsoup4>=4.12.0
 pandas>=2.0.0
 openai>=1.12.0
-lxml>=4.9.0
+lxml>=4.9.0
+google-auth>=2.0.0
+google-auth-oauthlib>=1.0.0
+google-auth-httplib2>=0.2.0

ui.py

@@ -44,22 +44,41 @@ class PageSpeedUI:
                 """)
                 return demo
                 
-            gr.Markdown("""
-            # 🚀 PageSpeed Insights Comparator
+            # Check if we're using real data or mock data
+            using_real_data = self.client and self.client.is_using_real_data()
             
-            Compare duas análises do PageSpeed Insights para monitorar melhorias em Core Web Vitals.
-            
-            **⚠️ DEMO MODE:** Atualmente usando dados simulados para demonstração, pois a API do PageSpeed Insights agora requer autenticação OAuth2 complexa.
-            
-            **Como usar:**
-            1. Cole a URL da primeira análise (baseline)
-            2. Cole a URL da segunda análise (atual)
-            3. Clique em "Comparar Análises"
-            
-            **Exemplo de URL:** `https://pagespeed.web.dev/analysis/https-www-example-com/abc123?form_factor=mobile`
-            
-            **Nota:** Os dados mostrados são simulados mas realistas, demonstrando a funcionalidade da ferramenta.
-            """)
+            if using_real_data:
+                gr.Markdown("""
+                # 🚀 PageSpeed Insights Comparator
+                
+                Compare duas análises do PageSpeed Insights para monitorar melhorias em Core Web Vitals.
+                
+                **✅ API REAL:** Conectado com Google PageSpeed Insights API usando OAuth2.
+                
+                **Como usar:**
+                1. Cole a URL da primeira análise (baseline)
+                2. Cole a URL da segunda análise (atual)
+                3. Clique em "Comparar Análises"
+                
+                **Exemplo de URL:** `https://pagespeed.web.dev/analysis/https-www-example-com/abc123?form_factor=mobile`
+                """)
+            else:
+                gr.Markdown("""
+                # 🚀 PageSpeed Insights Comparator
+                
+                Compare duas análises do PageSpeed Insights para monitorar melhorias em Core Web Vitals.
+                
+                **⚠️ DEMO MODE:** Usando dados simulados. Para dados reais, configure Google Service Account.
+                
+                **Como usar:**
+                1. Cole a URL da primeira análise (baseline)
+                2. Cole a URL da segunda análise (atual)
+                3. Clique em "Comparar Análises"
+                
+                **Exemplo de URL:** `https://pagespeed.web.dev/analysis/https-www-example-com/abc123?form_factor=mobile`
+                
+                **Configuração para dados reais:** Veja as instruções abaixo para configurar Google Service Account.
+                """)
             
             with gr.Row():
                 with gr.Column():
@@ -104,6 +123,42 @@ class PageSpeedUI:
                 inputs=[url1_input, url2_input],
                 outputs=[summary_output, table_output, ai_output]
             )
+            
+            # Add setup instructions if not using real data
+            if not using_real_data:
+                gr.Markdown("""
+                ---
+                ## 🔧 Configuração para Dados Reais
+                
+                Para usar dados reais do PageSpeed Insights API, siga estes passos:
+                
+                ### 1. Criar um Projeto Google Cloud
+                1. Acesse [Google Cloud Console](https://console.cloud.google.com/)
+                2. Crie um novo projeto ou selecione um existente
+                3. Ative a **PageSpeed Insights API**
+                
+                ### 2. Criar Service Account
+                1. Vá para **IAM & Admin** → **Service Accounts**
+                2. Clique em **Create Service Account**
+                3. Dê um nome (ex: `pagespeed-analyzer`)
+                4. Conceda o papel **Viewer** ou **Editor**
+                5. Clique em **Create Key** → **JSON**
+                6. Baixe o arquivo JSON
+                
+                ### 3. Configurar no Hugging Face Space
+                1. Vá para **Settings** → **Variables and secrets**
+                2. Adicione um novo secret:
+                   - **Name:** `GOOGLE_SERVICE_ACCOUNT_JSON`
+                   - **Value:** Cole todo o conteúdo do arquivo JSON baixado
+                3. Reinicie o Space
+                
+                ### 4. APIs Necessárias
+                Certifique-se que estas APIs estão ativadas no seu projeto:
+                - PageSpeed Insights API
+                - Cloud Resource Manager API (opcional)
+                
+                **Nota:** Pode levar alguns minutos para as mudanças fazerem efeito.
+                """)
         
         return demo