API ZenQuotes

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 ZenQuoteAPI:
    """Client pour l'API ZenQuote avec gestion des erreurs et méthodes utilitaires."""
    
    BASE_URL = "https://api.zenquote.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 philosophique 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_philosopher(cls, philosopher: str, limit: int = 10) -> List[Dict[str, Any]]:
        """Récupère des citations par philosophe."""
        try:
            params = {"philosopher": philosopher, "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 {philosopher}: {e}")
            raise
            
    @classmethod
    def get_quotes_by_tradition(cls, tradition: str, limit: int = 10) -> List[Dict[str, Any]]:
        """Récupère des citations par tradition philosophique."""
        try:
            params = {"tradition": tradition, "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 tradition {tradition}: {e}")
            raise
            
    @classmethod
    def get_mood_quote(cls, mood: str) -> Dict[str, Any]:
        """Récupère une citation adaptée à une humeur ou un contexte spécifique."""
        try:
            params = {"type": mood}
            response = requests.get(f"{cls.BASE_URL}/mood", params=params)
            return cls._handle_response(response)
        except Exception as e:
            logger.error(f"Échec lors de la récupération d'une citation pour l'humeur {mood}: {e}")
            raise

# Exemple d'utilisation
if __name__ == "__main__":
    try:
        # Obtenir une citation aléatoire
        quote = ZenQuoteAPI.get_random_quote()
        print(f'"{quote["content"]}" — {quote["author"]} ({quote.get("tradition", "Philosophie générale")})')
        
        # Obtenir des citations d'un philosophe spécifique
        philosopher_quotes = ZenQuoteAPI.get_quotes_by_philosopher("Confucius", 3)
        print(f"\nCitations de Confucius:")
        for i, q in enumerate(philosopher_quotes, 1):
            print(f"{i}. \"{q['content']}\"")
            
        # Obtenir des citations d'une tradition spécifique
        tradition_quotes = ZenQuoteAPI.get_quotes_by_tradition("Stoïcisme", 3)
        print(f"\nCitations stoïciennes:")
        for i, q in enumerate(tradition_quotes, 1):
            print(f"{i}. \"{q['content']}\" — {q['author']}")
            
        # Obtenir une citation adaptée à une humeur
        mood_quote = ZenQuoteAPI.get_mood_quote("sérénité")
        print(f"\nPour la sérénité: \"{mood_quote['content']}\" — {mood_quote['author']}")
            
    except Exception as e:
        print(f"Une erreur est survenue: {e}")

<?php
/**
 * Classe client pour l'API ZenQuote
 * Implémentation avec gestion d'erreurs, cache et fonctionnalités avancées
 */
class ZenQuoteAPI {
    private const BASE_URL = 'https://api.zenquote.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 => 'ZenQuoteAPI-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 philosophique aléatoire
     */
    public static function getRandomQuote(): array {
        return self::executeRequest('/random');
    }
    
    /**
     * Récupère des citations par philosophe
     */
    public static function getQuotesByPhilosopher(string $philosopher, int $limit = 10): array {
        $params = [
            'philosopher' => $philosopher,
            'limit' => $limit
        ];
        
        $result = self::executeRequest('/quotes', $params);
        return $result['results'] ?? [];
    }
    
    /**
     * Récupère des citations par tradition philosophique
     */
    public static function getQuotesByTradition(string $tradition, int $limit = 10): array {
        $params = [
            'tradition' => $tradition,
            'limit' => $limit
        ];
        
        $result = self::executeRequest('/quotes', $params);
        return $result['results'] ?? [];
    }
    
    /**
     * Récupère une citation adaptée à une humeur ou un contexte spécifique
     */
    public static function getMoodQuote(string $mood): array {
        $params = [
            'type' => $mood
        ];
        
        return self::executeRequest('/mood', $params);
    }
    
    /**
     * Récupère les traditions philosophiques disponibles
     */
    public static function getAvailableTraditions(): array {
        return self::executeRequest('/traditions');
    }
    
    /**
     * Récupère une valeur du cache
     */
    private static function getCache(string $key) {
        $cachePath = sys_get_temp_dir() . '/zenquote_' . $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() . '/zenquote_' . $key;
        file_put_contents($cachePath, serialize($value));
    }
}

// Exemple d'utilisation
try {
    // Obtenir une citation aléatoire
    $quote = ZenQuoteAPI::getRandomQuote();
    echo "\"" . $quote['content'] . "\" — " . $quote['author'];
    if (isset($quote['tradition'])) {
        echo " (" . $quote['tradition'] . ")";
    }
    echo "\n\n";
    
    // Obtenir des citations d'un philosophe spécifique
    $philosopherQuotes = ZenQuoteAPI::getQuotesByPhilosopher('Sénèque', 3);
    echo "Citations de Sénèque:\n";
    foreach ($philosopherQuotes as $index => $quote) {
        echo ($index + 1) . ". \"" . $quote['content'] . "\"\n";
    }
    
    // Obtenir des citations d'une tradition philosophique
    $traditionQuotes = ZenQuoteAPI::getQuotesByTradition('Bouddhisme', 3);
    echo "\nCitations de la tradition bouddhiste:\n";
    foreach ($traditionQuotes as $index => $quote) {
        echo ($index + 1) . ". \"" . $quote['content'] . "\" — " . $quote['author'] . "\n";
    }
    
    // Obtenir une citation adaptée à une humeur
    $moodQuote = ZenQuoteAPI::getMoodQuote('méditation');
    echo "\nPour la méditation: \"" . $moodQuote['content'] . "\" — " . $moodQuote['author'] . "\n";
    
    // Obtenir la liste des traditions disponibles
    $traditions = ZenQuoteAPI::getAvailableTraditions();
    echo "\nTraditions philosophiques disponibles:\n";
    foreach ($traditions as $index => $tradition) {
        echo ($index + 1) . ". " . $tradition['name'] . " (" . $tradition['quoteCount'] . " citations)\n";
    }
} catch (Exception $e) {
    echo "Erreur: " . $e->getMessage();
}
?>