Эффективное получение рейтингов фильмов BBFC с помощью Python

import requests
from bs4 import BeautifulSoup

def get_bbfc_rating(movie_title):
    # Примечание: это концептуальный пример - фактический скрейпинг BBFC требует
    # понимания структуры их веб-сайта и обработки динамического контента
    url = f"https://search.bbfc.co.uk/search?q={movie_title.replace(' ', '+')}"
    headers = {
        "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
    }
    
    try:
        response = requests.get(url, headers=headers)
        response.raise_for_status()
        
        soup = BeautifulSoup(response.content, 'html.parser')
        # Извлечение информации о рейтинге BBFC на основе фактической структуры сайта
        rating_element = soup.find('div', class_='rating-info')  # Пример класса
        return rating_element.text.strip() if rating_element else "Не найдено"
    except requests.RequestException as e:
        return f"Ошибка: {str(e)}"

from playwright.sync_api import sync_playwright

def get_bbfc_rating_playwright(movie_title):
    with sync_playwright() as p:
        browser = p.chromium.launch(headless=True)
        page = browser.new_page()
        
        try:
            page.goto(f"https://search.bbfc.co.uk/search?q={movie_title.replace(' ', '+')}")
            # Ожидание загрузки динамического контента
            page.wait_for_selector('.rating-info', timeout=10000)
            rating = page.query_selector('.rating-info').text_content()
            return rating.strip()
        except Exception as e:
            return f"Ошибка: {str(e)}"
        finally:
            browser.close()

import subprocess
import json

def get_bbfc_rating_puppeteer(movie_title):
    command = [
        'node', 'puppeteer_script.js',
        movie_title
    ]
    result = subprocess.run(command, capture_output=True, text=True)
    return json.loads(result.stdout)['rating']

import requests

def get_tmdb_classification(movie_title, api_key):
    url = f"https://api.themoviedb.org/3/search/movie"
    params = {
        'api_key': api_key,
        'query': movie_title,
        'language': 'en-GB'
    }
    
    response = requests.get(url, params=params)
    if response.status_code == 200:
        data = response.json()
        if data['results']:
            # TMDb может не иметь прямых рейтингов BBFC, но имеет данные о сертификации
            return data['results'][0]['certification']
    return None

def get_omdb_classification(movie_title, api_key):
    url = "http://www.omdbapi.com/"
    params = {
        'apikey': api_key,
        't': movie_title,
        'r': 'json'
    }
    
    response = requests.get(url, params=params)
    if response.status_code == 200:
        data = response.json()
        return data.get('Rated', 'Не оценен')
    return None

import requests

def get_apify_classification(movie_title, api_token):
    url = "https://api.apify.com/v2/acts/bebich~imdb-ratings/run-sync"
    headers = {'Content-Type': 'application/json'}
    payload = {
        'token': api_token,
        'input': {'movie': movie_title}
    }
    
    response = requests.post(url, json=payload, headers=headers)
    if response.status_code == 200:
        result = response.json()
        # Обработка структурированного JSON-ответа
        return result.get('data', {}).get('bbfc_rating')
    return None

from playwright.sync_api import sync_playwright
import json
import time

class BBFCScraper:
    def __init__(self):
        self.base_url = "https://search.bbfc.co.uk"
        
    def search_movie(self, movie_title, max_retries=3):
        """Поиск фильма и возврат классификации BBFC"""
        for attempt in range(max_retries):
            try:
                with sync_playwright() as p:
                    browser = p.chromium.launch(headless=True)
                    page = browser.new_page()
                    
                    # Установка пользовательского агента для избежания обнаружения
                    page.set_extra_http_headers({
                        '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'
                    })
                    
                    # Выполнение поиска
                    search_url = f"{self.base_url}/search?q={movie_title.replace(' ', '+')}"
                    page.goto(search_url)
                    
                    # Ожидание загрузки результатов поиска
                    page.wait_for_selector('.search-result-item', timeout=10000)
                    
                    # Получение деталей первого результата
                    first_result = page.query_selector('.search-result-item')
                    if first_result:
                        link = first_result.query_selector('a')
                        if link:
                            movie_url = link.get_attribute('href')
                            full_url = f"{self.base_url}{movie_url}"
                            
                            # Получение страницы подробной классификации
                            page.goto(full_url)
                            page.wait_for_selector('.classification-details', timeout=10000)
                            
                            # Извлечение информации о рейтинге
                            rating = self._extract_rating(page)
                            genre = self._extract_genre(page)
                            duration = self._extract_duration(page)
                            
                            return {
                                'title': movie_title,
                                'bbfc_rating': rating,
                                'genre': genre,
                                'duration': duration,
                                'url': full_url
                            }
                    
                    return None
                    
            except Exception as e:
                if attempt == max_retries - 1:
                    return {'error': str(e)}
                time.sleep(2)  # Ожидание перед повторной попыткой
                
    def _extract_rating(self, page):
        """Извлечение рейтинга классификации BBFC"""
        try:
            rating_element = page.query_selector('.rating-badge')
            return rating_element.text_content().strip() if rating_element else "Не оценен"
        except:
            return "Рейтинг не найден"
    
    def _extract_genre(self, page):
        """Извлечение жанра фильма"""
        try:
            genre_element = page.query_selector('.genre-list')
            return genre_element.text_content().strip() if genre_element else "Неизвестно"
        except:
            return "Неизвестно"
    
    def _extract_duration(self, page):
        """Извлечение длительности фильма"""
        try:
            duration_element = page.query_selector('.duration-info')
            return duration_element.text_content().strip() if duration_element else "Неизвестно"
        except:
            return "Неизвестно"

# Пример использования
if __name__ == "__main__":
    scraper = BBFCScraper()
    result = scraper.search_movie("Dune: Part Two")
    print(json.dumps(result, indent=2))

import requests
from functools import lru_cache
import time

class BBFCDataFetcher:
    def __init__(self, cache_ttl=3600):
        self.cache_ttl = cache_ttl
        self.last_request_time = 0
        self.min_request_interval = 2  # секунд между запросами
        
    def _rate_limit(self):
        """Реализация ограничения скорости"""
        current_time = time.time()
        time_since_last = current_time - self.last_request_time
        if time_since_last < self.min_request_interval:
            time.sleep(self.min_request_interval - time_since_last)
        self.last_request_time = current_time
    
    @lru_cache(maxsize=100)
    def get_movie_classification(self, movie_title):
        """Получение классификации фильма с кэшированием и ограничением скорости"""
        self._rate_limit()
        
        # Попытка использования API в первую очередь
        api_result = self._try_api(movie_title)
        if api_result:
            return api_result
            
        # Откат к скрейпингу
        return self._try_scraping(movie_title)
    
    def _try_api(self, movie_title):
        """Попытка получения данных из сторонних API"""
        # Пример с TMDb
        tmdb_api_key = "your_tmdb_api_key"
        if tmdb_api_key:
            try:
                url = "https://api.themoviedb.org/3/search/movie"
                params = {
                    'api_key': tmdb_api_key,
                    'query': movie_title,
                    'language': 'en-GB'
                }
                response = requests.get(url, params=params, timeout=10)
                if response.status_code == 200:
                    data = response.json()
                    if data.get('results'):
                        return {
                            'source': 'TMDb API',
                            'rating': data['results'][0].get('certification'),
                            'title': movie_title
                        }
            except Exception:
                pass
                
        return None
    
    def _try_scraping(self, movie_title):
        """Попытка веб-скрейпинга как запасной вариант"""
        # Реализуйте фактическую логику скрейпинга здесь
        return {'source': 'scraping', 'title': movie_title, 'rating': 'Unknown'}