python-filmaffinity 0.0.21__py3-none-any.whl

python_filmaffinity/__init__.py

@@ -0,0 +1,254 @@
+# -*- coding: utf-8 -*-
+from .__meta__ import *
+from .client import Client
+from .config import FIELDS_TYPE
+
+class FilmAffinity(Client):
+
+    def get_movie(self, trailer=False, images=False, **kwargs):
+        """Return a dictionary with the data of the movie.
+
+        Args:
+            title: Search by title
+            id: Search by id
+            trailer: Enable/Disable search a trailer
+            images: Enable/Disable search for images
+        Returns:
+            TYPE: Dictionary with movie data
+        """
+        movie = {}
+        if kwargs is not None:
+            for key, value in iter(kwargs.items()):
+                if key == 'id':
+                    movie = self._get_movie_by_id(
+                        value, trailer, images)
+                else:
+                    movie = self._get_movie_by_args(
+                        key, value, trailer, images)
+        return movie
+
+    def search(self, top=10, **kwargs):
+        """Return a list with the data of the movies.
+
+        Args:
+            title: Search by title
+            director: Search by director
+            cast: Search by cast
+            from_year: Search from the year
+            to_year: Search until the year
+            genre: 
+                AN: Animación
+                AV: Aventuras
+                BE: Bélico
+                C-F: Ciencia Ficción
+                F-N: Cine Negro
+                CO: Comedia
+                DESC: Desconocido
+                DO: Documental
+                DR: Drama
+                FAN: Fantástico
+                INF: Infantil
+                INT: Intriga
+                MU: Musical
+                RO: Romance
+                TV_SE: Serie de TV
+                TE: Terror
+                WE: Western
+        Returns:
+            TYPE: Lis with movies data
+        """
+        top = 20 if top > 20 else top
+        movies = []
+        if kwargs is not None:
+            options = ''
+            simple_search = 'title' in kwargs
+            for key, value in iter(kwargs.items()):
+                if key in FIELDS_TYPE:
+                    if (key != 'title'):
+                        simple_search = False
+                    options += 'stext=%s&stype[]=%s&' % (str(kwargs[key]), key)
+                if key == 'from_year':
+                    options += 'fromyear=%s&' % value
+                if key == 'to_year':
+                    options += 'toyear=%s&' % value
+                if key == 'genre':
+                    options += 'genre=%s&' % value
+            if (simple_search):
+                options = 'stype=title&stext=' + str(kwargs['title'])
+                url = self.url + 'search.php?' + options
+            else:
+                url = self.url + 'advsearch.php?' + options
+            page = self._load_url(url)
+            movies = self._return_list_movies(page, 'search', top)
+            if (len(movies) == 0):
+                url = self.url + 'advsearch.php?' + options
+                page = self._load_url(url)
+                movies = self._return_list_movies(page, 'search', top)
+        return movies
+
+    def top_filmaffinity(self, top=10, **kwargs):
+        """Return a list with the top filmaffinity movies.
+
+        Args:
+
+            from_year: Search from the year
+            to_year: Search until the year
+        Returns:
+            TYPE: Lis with movies data
+        """
+        top = 30 if top > 30 else top
+        movies = []
+        if kwargs is not None:
+            options = ''
+            for key, value in iter(kwargs.items()):
+                if key == 'from_year':
+                    options += 'fromyear=%s&' % value
+                if key == 'to_year':
+                    options += 'toyear=%s&' % value
+        if options:
+            url = self.url + 'topgen.php?' + options
+        else:
+            url = self.url + 'topgen.php'
+        page = self._load_url(url)
+        movies = self._return_list_movies(page, 'top', top)
+        return movies
+
+    def top_tv_series(self, top=10, **kwargs):
+        """Return a list with the top tv series.
+
+        Args:
+
+            from_year: Search from the year
+            to_year: Search until the year
+        Returns:
+            TYPE: Lis with movies data
+        """
+        top = 30 if top > 30 else top
+        movies = []
+        if kwargs is not None:
+            options = ''
+            for key, value in iter(kwargs.items()):
+                if key == 'from_year':
+                    options += 'fromyear=%s&' % value
+                if key == 'to_year':
+                    options += 'toyear=%s&' % value
+        if options:
+            url = self.url + 'topgen.php?genre=TV_SE&' + options
+        else:
+            url = self.url + 'topgen.php?genre=TV_SE'
+        page = self._load_url(url)
+        movies = self._return_list_movies(page, 'top', top)
+        return movies
+
+    def top_dvd(self, top=10):
+        """Return a list with the top new dvds.
+
+        Returns:
+            TYPE: Lis with movies data
+        """
+        top = 40 if top > 40 else top
+        movies = []
+        if self.lang == 'es':
+            url = self.url + 'topcat_new_sa_es.html'
+        else:
+            url = self.url + 'topcat_DVD_VID_US.html'
+        page = self._load_url(url)
+        movies = self._return_list_movies(page, 'top_service', top)
+        return movies
+
+    def top_premieres(self, top=10):
+        """Return a list with the top filmaffinity movies.
+
+        Args:
+
+            from_year: Search from the year
+            to_year: Search until the year
+        Returns:
+            TYPE: Lis with movies data
+        """
+        top = 40 if top > 40 else top
+        movies = []
+        url = self.url + 'topcat_new_th_es.html'
+        page = self._load_url(url)
+        movies = self._return_list_movies(page, 'top_service', top)
+        return movies
+
+    def top_netflix(self, top=10):
+        """Return a list with the top netflix movies.
+
+        Returns:
+            TYPE: Lis with movies data
+        """
+        return self._top_service(top, 'new_netflix')
+
+    def top_hbo(self, top=10):
+        """Return a list with the top hbo movies.
+
+        Returns:
+            TYPE: Lis with movies data
+        """
+        return self._top_service(top, 'new_hbo_es')
+
+    def top_filmin(self, top=10):
+        """Return a list with the top filmin movies.
+
+        Returns:
+            TYPE: Lis with movies data
+        """
+        return self._top_service(top, 'new_filmin')
+
+    def top_movistar(self, top=10):
+        """Return a list with the top movistar movies.
+
+        Returns:
+            TYPE: Lis with movies data
+        """
+        return self._top_service(top, 'new_movistar_f')
+
+    def top_rakuten(self, top=10):
+        """Return a list with the top rakuten movies.
+
+        Returns:
+            TYPE: Lis with movies data
+        """
+        return self._top_service(top, 'new_rakuten')
+
+    def recommend_netflix(self, trailer=False, images=False):
+        """Return a movie random in Netflix.
+
+        Returns:
+            TYPE: Movie data
+        """
+        return self._recommend('new_netflix', trailer, images)
+
+    def recommend_hbo(self, trailer=False, images=False):
+        """Return a movie random in HBO.
+
+        Returns:
+            TYPE: Movie data
+        """
+        return self._recommend('new_hbo_es', trailer, images)
+
+    def recommend_movistar(self, trailer=False, images=False):
+        """Return a movie random in Movistar.
+
+        Returns:
+            TYPE: Movie data
+        """
+        return self._recommend('new_movistar_f', trailer, images)
+
+    def recommend_rakuten(self, trailer=False, images=False):
+        """Return a movie random in Rakuten.
+
+        Returns:
+            TYPE: Movie data
+        """
+        return self._recommend('new_rakuten', trailer, images)
+
+    def recommend_filmin(self, trailer=False, images=False):
+        """Return a movie random in Filmin.
+
+        Returns:
+            TYPE: Movie data
+        """
+        return self._recommend('new_filmin', trailer, images)

python_filmaffinity/__meta__.py

@@ -0,0 +1,19 @@
+"""Project metadata.
+"""
+
+__title__ = 'python_filmaffinity'
+__summary__ = 'Python wrapper for FilmAffinity'
+__url__ = 'https://github.com/sergiormb/python_filmaffinity'
+
+__version__ = '0.0.21'
+
+__install_requires__ = [
+    'beautifulsoup4>=4.9.1',
+    'requests>=2.24.0',
+    'requests-cache>=1.0.0',
+]
+
+__author__ = 'sergiormb'
+__email__ = 'sergiormb88@gmail.com'
+
+__license__ = 'MIT'

python_filmaffinity/client.py

@@ -0,0 +1,379 @@
+#!/usr/bin/env python
+# -*- coding: utf-8 -*-
+import logging
+
+import requests
+import requests_cache
+import random
+
+from bs4 import BeautifulSoup
+from inspect import getsourcefile
+from os.path import join, dirname, abspath
+from .config import FIELDS_MOVIE
+from .pages import DetailPage, SearchPage, TopPage, TopServicePage, ImagesPage
+from .exceptions import (
+    FilmAffinityInvalidLanguage,
+    FilmAffinityInvalidBackend,
+    FilmAffinityConnectionError)
+from .proxies import get_random_proxy
+try:
+    from urllib import quote  # Python 2.X
+except ImportError:
+    from urllib.parse import quote  # Python 3+
+
+current_folder = dirname(abspath(getsourcefile(lambda: 0)))
+supported_languages = ['en', 'es', 'mx', 'ar', 'cl', 'co']
+USER_AGENTS = [
+    'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 '
+    '(KHTML, like Gecko) Chrome/125.0 Safari/537.36',
+    'Mozilla/5.0 (Macintosh; Intel Mac OS X 14_5) AppleWebKit/605.1.15 '
+    '(KHTML, like Gecko) Version/17.5 Safari/605.1.15',
+    'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 '
+    '(KHTML, like Gecko) Chrome/125.0 Safari/537.36',
+]
+
+
+class Client:
+    """Client to make requests to FilmAffinity.
+        Args:
+            lang: Language, one of: ('en', 'es', 'mx', 'ar', 'cl', 'co')
+            cache_path: Path to FilmAffinity Database (If not set, the
+                database will be stored inside python_filmaffinity path)
+            cache_backend: One of (sqlite, mongodb, memory, redis). Set to
+                memory or None if you don't wont persistent cache
+                (defaults to sqlite).
+                Note for backends (from requests-cache docs):
+                    'sqlite' - sqlite database
+                    'memory' - not persistent,
+                        stores all data in Python dict in memory
+                    'mongodb' - (experimental) MongoDB database
+                        (pymongo < 3.0 required)
+                    'redis' - stores all data on a redis data store
+                        (redis required)
+            cache_expires: Time in seconds to force new requests from the
+                server (defaults to 86400, 24 hours)
+            cache_remove_expired: Force to remove expired responses after any
+                requests call. This will ensure that if any call to
+                FilmAffinity fails and we already made that call we will get a
+                response at a cost of a bigger database file (defaults to True)
+
+    """
+
+    base_url = 'https://www.filmaffinity.com/'
+
+    def __init__(self, lang='es', cache_path=None,
+                 cache_backend='sqlite', cache_expires=86400,
+                 cache_remove_expired=True):
+        """Init the search service.
+
+        Args:
+            lang (str, optional): Language of the page
+        """
+        if lang not in supported_languages:
+            raise FilmAffinityInvalidLanguage(
+                lang, supported_languages)
+        if cache_backend not in ['sqlite', 'memory', 'mongodb', 'redis', None]:
+            raise FilmAffinityInvalidBackend(
+                cache_backend)
+        self.lang = lang
+
+        self.url = self.base_url + self.lang + '/'
+        self.url_film = self.url + 'film'
+        self.url_images = self.url + 'filmimages.php?movie_id='
+        self.url_trailers = self.url + 'evideos.php?movie_id='
+
+        # initialize requests-cache
+        self.cache_expires = cache_expires
+        self.cache_backend = cache_backend if cache_backend else 'memory'
+        self.cache_path = self._get_cache_file(cache_path)
+        self.cache_remove_expired = cache_remove_expired
+        self.session = None
+        self.session_headers = {
+            'User-Agent': random.choice(USER_AGENTS)
+        }
+
+    def _generate_new_session_headers(self):
+        self.session_headers = {
+            'User-Agent': random.choice(USER_AGENTS)
+        }
+
+    def _get_cache_file(self, cache_path=None):
+        """Returns the cache file used by requests-cache
+        """
+        c = None
+        if self.cache_backend in ['memory']:
+            c = 'cache-film-affinity'
+        elif cache_path:
+            c = join(cache_path, "cache-film-affinity")
+        else:
+            c = join(current_folder, "cache-film-affinity")
+        return c
+
+    def _get_requests_session(self):
+        """Initialize requests Session"""
+        self.session = requests_cache.CachedSession(
+            expire_after=self.cache_expires,
+            backend=self.cache_backend,
+            cache_name=self.cache_path,
+            include_get_headers=True,
+            old_data_on_error=True
+            )
+        if self.cache_remove_expired:
+            if hasattr(self.session.cache, 'delete'):
+                self.session.cache.delete(expired=True)
+            else:
+                remove_expired = getattr(
+                    self.session, 'remove_expired_responses', None)
+                if remove_expired is None:
+                    remove_expired = getattr(
+                        self.session.cache, 'remove_expired_responses', None)
+                if remove_expired:
+                    remove_expired()
+
+    def _load_url(self, url, headers=None, verify=None,
+                  timeout=3, force_server_response=False):
+        """Return response from The FilmAffinity"""
+        self._generate_new_session_headers()
+        kwargs = {'headers': self.session_headers}
+        proxies = get_random_proxy()
+        if proxies:
+            kwargs.update({"proxies": proxies})
+        if headers:
+            kwargs['verify'] = verify
+        if headers:
+            kwargs['headers'] = headers
+        if timeout:
+            kwargs['timeout'] = timeout
+        if not self.session:
+            self._get_requests_session()
+        try:
+            if not force_server_response:
+                response = self.session.get(url, **kwargs)
+            else:
+                with self.session.cache_disabled():
+                    response = self.session.get(url, **kwargs)
+        except requests.exceptions.ConnectionError as er:
+            raise FilmAffinityConnectionError(er)
+        logging.warning(f"Filmaffinty Client: GET {url}")
+        return response
+
+    def _get_trailer(self, fa_id):
+        page = self._load_url(self.url_trailers + str(fa_id))
+        soup = BeautifulSoup(page.content, "html.parser")
+        vid = [i['src'] for i in soup.find_all('iframe')]
+        return vid
+
+    def _get_movie_images(self, fa_id):
+        url = self.url_images + str(fa_id)
+        r = self._load_url(url)
+        soup = BeautifulSoup(r.content, "html.parser")
+        exist = soup.find_all("div", {"id": 'main-image-wrapper'})
+        if not exist:
+            return {
+                'posters': [],
+                'stills': [],
+                'promo': [],
+                'events': [],
+                'shootings': []}
+        page = ImagesPage(soup)
+        return {
+            'posters': page.get_posters(),
+            'stills': page.get_stills(),
+            'promo': page.get_promos(),
+            'events': page.get_events(),
+            'shootings': page.get_shootings(),
+        }
+
+    def _get_movie_data(self, page, fa_id=None):
+        result = {
+            'id': None,
+            'title': None,
+            'original_title': None,
+            'year': None,
+            'duration': None,
+            'rating': None,
+            'votes': None,
+            'description': None,
+            'directors': None,
+            'writers': None,
+            'music': None,
+            'cinematography': None,
+            'actors': None,
+            'producers': None,
+            'poster': None,
+            'country': None,
+            'genre': None,
+            'awards': None,
+            'reviews': None
+        }
+        # Update the dictionary with values from functions, handling exceptions
+        try:
+            result['id'] = fa_id or page.get_id()
+        except Exception as e:
+            logging.warning(f"Id field not found: {e}")
+
+        try:
+            result['title'] = page.get_title()
+        except Exception as e:
+            logging.warning(f"Title field not found for {result.get('id')}: {e}")
+
+        try:
+            result['original_title'] = page.get_original_title()
+        except Exception as e:
+            logging.warning(f"Original title field not found for {result.get('id')}: {e}")
+
+        try:
+            result['year'] = page.get_year()
+        except Exception as e:
+            logging.warning(f"Year field not found for {result.get('id')}: {e}")
+
+        try:
+            result['duration'] = page.get_duration()
+        except Exception as e:
+            logging.warning(f"Duration field not found for {result.get('id')}: {e}")
+
+        try:
+            result['rating'] = page.get_rating()
+        except Exception as e:
+            logging.warning(f"Rating field not found for {result.get('id')}: {e}")
+
+        try:
+            result['votes'] = page.get_number_of_votes()
+        except Exception as e:
+            logging.warning(f"Votes field not found for {result.get('id')}: {e}")
+
+        try:
+            result['description'] = page.get_description()
+        except Exception as e:
+            logging.warning(f"Description field not found for {result.get('id')}: {e}")
+
+        try:
+            result['directors'] = page.get_directors()
+        except Exception as e:
+            logging.warning(f"Directors field not found for {result.get('id')}: {e}")
+
+        try:
+            result['writers'] = page.get_writers()
+        except Exception as e:
+            logging.warning(f"Writers field not found for {result.get('id')}: {e}")
+
+        try:
+            result['music'] = page.get_music()
+        except Exception as e:
+            logging.warning(f"Music field not found for {result.get('id')}: {e}")
+
+        try:
+            result['cinematography'] = page.get_cinematography()
+        except Exception as e:
+            logging.warning(f"Cinematography field not found for {result.get('id')}: {e}")
+
+        try:
+            result['actors'] = page.get_actors()
+        except Exception as e:
+            logging.warning(f"Actors field not found for {result.get('id')}: {e}")
+
+        try:
+            result['producers'] = page.get_producers()
+        except Exception as e:
+            logging.warning(f"Producers field not found for {result.get('id')}: {e}")
+
+        try:
+            result['poster'] = page.get_poster()
+        except Exception as e:
+            logging.warning(f"Poster field not found for {result.get('id')}: {e}")
+
+        try:
+            result['country'] = page.get_country()
+        except Exception as e:
+            logging.warning(f"Country field not found for {result.get('id')}: {e}")
+
+        try:
+            result['genre'] = page.get_genre()
+        except Exception as e:
+            logging.warning(f"Genre field not found for {result.get('id')}: {e}")
+
+        try:
+            result['awards'] = page.get_awards()
+        except Exception as e:
+            logging.warning(f"Awards field not found for {result.get('id')}: {e}")
+
+        try:
+            result['reviews'] = page.get_reviews()
+        except Exception as e:
+            logging.warning(f"Reviews field not found for {result.get('id')}: {e}")
+
+        return result
+
+    def _get_movie_by_id(self, id, trailer=False, images=False):
+        movie = {}
+        page = self._load_url(self.url_film + str(id) + '.html')
+        soup = BeautifulSoup(page.content, "html.parser")
+        exist = soup.find_all("div", {"class": 'z-movie'})
+        if exist:
+            page = DetailPage(soup)
+            movie = self._get_movie_data(page, fa_id=id)
+            if trailer:
+                trailer_url = self._get_trailer(fa_id=id)
+                if trailer_url:
+                    movie.update({'trailer': trailer_url})
+        if images and movie.get('id', False):
+            movie.update({'images': self._get_movie_images(movie['id'])})
+        return movie
+
+    def _get_movie_by_args(self, key, value, trailer=False, images=False):
+        movie = {}
+        if key in FIELDS_MOVIE:
+            options = '&stype[]=%s' % key
+            url = self.url + 'advsearch.php?stext=' + \
+                str(value) + options
+            page = self._load_url(url)
+            soup = BeautifulSoup(page.content, "html.parser")
+            movies_cell = soup.find_all("div", {"class": 'movie-card-1'})
+            if movies_cell:
+                cell = movies_cell[0]
+                id = str(cell['data-movie-id'])
+                movie = self._get_movie_by_id(id, trailer, images)
+        return movie
+
+    def _return_list_movies(self, page, method, top=10):
+        movies = []
+        soup = BeautifulSoup(page.content, "html.parser")
+        if method == 'top':
+            movies_list = soup.find("ul", {"id": 'top-movies'})
+            movies_cell = movies_list.select(
+                ".movie-card[data-movie-id]"
+            ) if movies_list else []
+            class_ = TopPage
+        if method == 'search':
+            movies_cell = soup.select(".movie-card[data-movie-id]")
+            class_ = SearchPage
+        if method == 'top_service':
+            wrapper = soup.select(".top-movie .movie-card[data-movie-id]")
+            movies_cell = wrapper or soup.select(".movie-card[data-movie-id]")
+            class_ = TopServicePage
+        for cell in movies_cell[:top]:
+            page = class_(cell)
+            movie = self._get_movie_data(page)
+            movies.append(movie)
+        return movies
+
+    def _recommend(self, service, trailer=False, images=False):
+        movie = {}
+        url = self.url + 'topcat.php?id=' + service
+        page = self._load_url(url)
+        soup = BeautifulSoup(page.content, "html.parser")
+        movies_cell = soup.select(".movie-card[data-movie-id]")
+        if not movies_cell:
+            return movie
+        cell = random.choice(movies_cell)
+        id = str(cell['data-movie-id'])
+        movie = self._get_movie_by_id(id, trailer, images)
+        return movie
+
+    def _top_service(self, top, service):
+        movies = []
+        top = 40 if top > 40 else top
+        url = self.url + 'topcat.php?id=' + service
+        page = self._load_url(url)
+        movies = self._return_list_movies(page, 'top_service', top)
+        return movies

python_filmaffinity/config.py

@@ -0,0 +1,11 @@
+"""Config."""
+# -*- coding: utf-8 -*-
+
+FIELDS_MOVIE = ['title', 'id']
+FIELDS_TYPE = ['title', 'director', 'cast', 'stext']
+
+
+FIELDS_PAGE_MOVIES = ['id', 'title', 'rating', 'directors', 'poster']
+FIELDS_DETAIL = ['description', 'votes', 'year', 'country', 'duration',
+                 'genre', 'awards', 'reviews', 'actors']
+FIELDS_PAGE_DETAIL = FIELDS_PAGE_MOVIES + FIELDS_DETAIL