API Quotable

import requests
import logging
from typing import Dict, List, Optional, Any

# Configuration du logging
logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
logger = logging.getLogger(__name__)

class QuotableAPI:
    """Client pour l'API Quotable avec gestion des erreurs et méthodes utilitaires."""
    
    BASE_URL = "https://api.quotable.io"
    
    @staticmethod
    def _handle_response(response: requests.Response) -> Dict[str, Any]:
        """Gère la réponse HTTP et les erreurs potentielles."""
        try:
            response.raise_for_status()
            return response.json()
        except requests.exceptions.HTTPError as e:
            logger.error(f"Erreur HTTP: {e}")
            raise
        except requests.exceptions.RequestException as e:
            logger.error(f"Erreur de requête: {e}")
            raise
        except ValueError as e:
            logger.error(f"Erreur de décodage JSON: {e}")
            raise
    
    @classmethod
    def get_random_quote(cls) -> Dict[str, Any]:
        """Récupère une citation aléatoire."""
        try:
            response = requests.get(f"{cls.BASE_URL}/random")
            return cls._handle_response(response)
        except Exception as e:
            logger.error(f"Échec lors de la récupération d'une citation aléatoire: {e}")
            raise
    
    @classmethod
    def get_quotes_by_author(cls, author: str, limit: int = 10) -> List[Dict[str, Any]]:
        """Récupère des citations par auteur."""
        try:
            params = {"author": author, "limit": limit}
            response = requests.get(f"{cls.BASE_URL}/quotes", params=params)
            data = cls._handle_response(response)
            return data.get("results", [])
        except Exception as e:
            logger.error(f"Échec lors de la récupération des citations de {author}: {e}")
            raise

# Exemple d'utilisation
if __name__ == "__main__":
    try:
        # Obtenir une citation aléatoire
        quote = QuotableAPI.get_random_quote()
        print(f'"{quote["content"]}" — {quote["author"]}')
        
        # Obtenir des citations d'un auteur spécifique
        author_quotes = QuotableAPI.get_quotes_by_author("Albert Einstein", 3)
        print(f"\nCitations d'Albert Einstein:")
        for i, q in enumerate(author_quotes, 1):
            print(f"{i}. \"{q['content']}\"")
            
    except Exception as e:
        print(f"Une erreur est survenue: {e}")

<?php
/**
 * Classe client pour l'API Quotable
 * Implémentation avec gestion d'erreurs et cache
 */
class QuotableAPI {
    private const BASE_URL = 'https://api.quotable.io';
    private const CACHE_DURATION = 3600; // 1 heure en secondes
    
    /**
     * Exécute une requête vers l'API avec gestion d'erreurs
     */
    private static function executeRequest(string $endpoint, array $params = []): array {
        $url = self::BASE_URL . $endpoint;
        
        if (!empty($params)) {
            $url .= '?' . http_build_query($params);
        }
        
        // Vérifier si le résultat est en cache
        $cacheKey = md5($url);
        $cachedResult = self::getCache($cacheKey);
        
        if ($cachedResult !== false) {
            return $cachedResult;
        }
        
        $curl = curl_init($url);
        curl_setopt_array($curl, [
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT => 10,
            CURLOPT_USERAGENT => 'QuotableAPI-PHP-Client/1.0',
            CURLOPT_HTTPHEADER => ['Accept: application/json']
        ]);
        
        $response = curl_exec($curl);
        $httpCode = curl_getinfo($curl, CURLINFO_HTTP_CODE);
        $error = curl_error($curl);
        curl_close($curl);
        
        if ($error) {
            throw new Exception("Erreur cURL: " . $error);
        }
        
        if ($httpCode >= 400) {
            throw new Exception("Erreur HTTP " . $httpCode . ": " . $response);
        }
        
        $result = json_decode($response, true);
        
        if (json_last_error() !== JSON_ERROR_NONE) {
            throw new Exception("Erreur de décodage JSON: " . json_last_error_msg());
        }
        
        // Mettre en cache le résultat
        self::setCache($cacheKey, $result);
        
        return $result;
    }
    
    /**
     * Récupère une citation aléatoire
     */
    public static function getRandomQuote(): array {
        return self::executeRequest('/random');
    }
    
    /**
     * Récupère des citations par auteur
     */
    public static function getQuotesByAuthor(string $author, int $limit = 10): array {
        $params = [
            'author' => $author,
            'limit' => $limit
        ];
        
        $result = self::executeRequest('/quotes', $params);
        return $result['results'] ?? [];
    }
    
    /**
     * Récupère une valeur du cache
     */
    private static function getCache(string $key) {
        $cachePath = sys_get_temp_dir() . '/quotable_' . $key;
        
        if (file_exists($cachePath) && (time() - filemtime($cachePath)) < self::CACHE_DURATION) {
            return unserialize(file_get_contents($cachePath));
        }
        
        return false;
    }
    
    /**
     * Met une valeur en cache
     */
    private static function setCache(string $key, $value): void {
        $cachePath = sys_get_temp_dir() . '/quotable_' . $key;
        file_put_contents($cachePath, serialize($value));
    }
}

// Exemple d'utilisation
try {
    // Obtenir une citation aléatoire
    $quote = QuotableAPI::getRandomQuote();
    echo "\"" . $quote['content'] . "\" — " . $quote['author'] . "\n\n";
    
    // Obtenir des citations d'un auteur spécifique
    $authorQuotes = QuotableAPI::getQuotesByAuthor('Albert Einstein', 3);
    echo "Citations d'Albert Einstein:\n";
    foreach ($authorQuotes as $index => $quote) {
        echo ($index + 1) . ". \"" . $quote['content'] . "\"\n";
    }
} catch (Exception $e) {
    echo "Erreur: " . $e->getMessage();
}
?>