themoviedb-lib 0.0.1__tar.gz

themoviedb-lib-0.0.1/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 inwerk
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

themoviedb-lib-0.0.1/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: themoviedb-lib
+Version: 0.0.1
+Home-page: https://github.com/inwerk/themoviedb-lib
+Author: 
+Author-email: 
+Keywords: python,development,tmdb
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: fake-useragent
+
+# The Movie Database (TMDb) Python Library

themoviedb-lib-0.0.1/README.md

@@ -0,0 +1 @@
+# The Movie Database (TMDb) Python Library

themoviedb-lib-0.0.1/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

themoviedb-lib-0.0.1/setup.py

@@ -0,0 +1,31 @@
+from setuptools import setup, find_packages
+import pathlib
+
+here = pathlib.Path(__file__).parent.resolve()
+
+# Get the long description from the README file
+long_description = (here / "README.md").read_text(encoding="utf-8")
+
+# Setting up
+setup(
+    name="themoviedb-lib",  # Required
+    version="0.0.1",  # Required
+    description="",  # Optional
+    long_description=long_description,  # Optional
+    long_description_content_type="text/markdown",  # Optional
+    url="https://github.com/inwerk/themoviedb-lib",  # Optional
+    author="",  # Optional
+    author_email="",  # Optional
+    classifiers=[  # Optional (https://pypi.org/classifiers/)
+        "Development Status :: 1 - Planning",
+        "Intended Audience :: Developers",
+        "Topic :: Software Development :: Build Tools",
+        "License :: OSI Approved :: MIT License",
+        "Programming Language :: Python :: 3",
+        "Programming Language :: Python :: 3.11",
+        "Programming Language :: Python :: 3 :: Only"
+    ],
+    keywords=["python", "development", "tmdb"],  # Optional
+    packages=find_packages(),  # Required
+    install_requires=['requests', 'beautifulsoup4', 'fake-useragent']  # Optional
+)

themoviedb-lib-0.0.1/themoviedb_lib.egg-info/PKG-INFO

@@ -0,0 +1,21 @@
+Metadata-Version: 2.1
+Name: themoviedb-lib
+Version: 0.0.1
+Home-page: https://github.com/inwerk/themoviedb-lib
+Author: 
+Author-email: 
+Keywords: python,development,tmdb
+Classifier: Development Status :: 1 - Planning
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Software Development :: Build Tools
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3 :: Only
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: requests
+Requires-Dist: beautifulsoup4
+Requires-Dist: fake-useragent
+
+# The Movie Database (TMDb) Python Library

themoviedb-lib-0.0.1/themoviedb_lib.egg-info/SOURCES.txt

@@ -0,0 +1,13 @@
+LICENSE
+README.md
+setup.py
+themoviedb_lib.egg-info/PKG-INFO
+themoviedb_lib.egg-info/SOURCES.txt
+themoviedb_lib.egg-info/dependency_links.txt
+themoviedb_lib.egg-info/requires.txt
+themoviedb_lib.egg-info/top_level.txt
+tmdb/__init__.py
+tmdb/tests/__init__.py
+tmdb/tests/test_tmdb_api.py
+tmdb/tests/test_tmdb_entry.py
+tmdb/tests/test_tmdb_request.py

themoviedb-lib-0.0.1/themoviedb_lib.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

themoviedb-lib-0.0.1/themoviedb_lib.egg-info/requires.txt

@@ -0,0 +1,3 @@
+requests
+beautifulsoup4
+fake-useragent

themoviedb-lib-0.0.1/themoviedb_lib.egg-info/top_level.txt

@@ -0,0 +1 @@
+tmdb

themoviedb-lib-0.0.1/tmdb/__init__.py

@@ -0,0 +1,499 @@
+import io
+import re
+import requests
+
+from bs4 import BeautifulSoup
+from fake_useragent import UserAgent
+from functools import cache
+from typing import Optional
+
+
+class Request:
+    """ Class providing methods for sending HTTP requests to the website <www.themoviedb.org>. """
+
+    @classmethod
+    def get(cls, path: str = "", query: str = "", stream: bool = False) -> requests.Response:
+        """
+        Sends an HTTP GET request to TMDb and returns the response.
+
+        :param path: URL path.
+        :param query: URL query string.
+        :param stream: Set this parameter for downloading images.
+        :return: Response.
+        """
+
+        # build a TMDb URL
+        url = f"https://www.themoviedb.org{path}?{query}"
+
+        # headers to send with the request
+        headers = {"User-Agent": UserAgent().random}
+
+        # send a GET request using URL and headers
+        response = requests.get(url, headers=headers, stream=stream)
+
+        # if the response status code was between 200 and 400, return the response
+        if response:
+            return response
+
+        # HTTP 404: The requested resource was not found
+        if response.status_code == 404:
+            raise Exception(f"The resource www.themoviedb.org{path} does not exist.")
+
+        # other HTTP status codes
+        raise Exception(f"An error occurred while handling your request to www.themoviedb.org{path}.")
+
+    @classmethod
+    def image(cls, file_path: str) -> io.BytesIO:
+        """
+        Downloads an image from TMDb.
+
+        :param file_path: Path to the image.
+        :return: Image as BytesIO.
+        """
+
+        response = Request.get(path=file_path, stream=True)
+
+        return io.BytesIO(response.content)
+
+
+class API:
+    """ Class providing methods for sending and processing TMDb API requests. """
+
+    @classmethod
+    @cache
+    def languages(cls, iso_639: bool = True) -> list:
+        """
+        Returns a list of languages supported by TMDb.
+
+        :param iso_639: Return ISO-639-1 formatted language codes.
+        :return: List of supported languages as IETF language tags.
+        """
+
+        # get HTTP response for the TMDb start page
+        response = Request.get()
+
+        # parse response to BeautifulSoup object
+        html_page = BeautifulSoup(response.text, features="html.parser")
+
+        # extract language codes from HTML page
+        languages = []
+        for link_rel in html_page.find_all("link", {"rel": "alternate"}):
+
+            # if string is IETF language tag
+            if re.fullmatch(r"[a-z]{2}-[A-Z]{2}", link_rel.get("hreflang")):
+                language = link_rel.get("hreflang")
+
+                # ISO-639-1 formatted language codes
+                if iso_639:
+                    # remove territory from IETF language tag (e.g. "-DE" or "-AT"
+                    language = re.search(r"[a-z]{2}", language).group()
+
+                    # ignore duplicates (e.g. "de-DE" and "de-AT")
+                    if language in languages:
+                        continue
+
+                    # "cn" (Cantonese) is not included in the ISO-639-1 standard
+                    if language == "cn":
+                        continue
+
+                # add language tag to list
+                languages.append(language)
+
+        return languages
+
+    @classmethod
+    @cache
+    def categories(cls) -> list:
+        """
+        Returns a list of categories supported by TMDb.
+
+        :return: List of supported categories as strings.
+        """
+
+        # get HTTP response for the TMDb search page
+        response = Request.get(path="/search")
+
+        # parse response to BeautifulSoup object
+        html_page = BeautifulSoup(response.text, features="html.parser")
+
+        # extract categories from HTML page
+        categories = []
+        for a_search_tab in html_page.find_all("a", {"class": "search_tab"}):
+            if a_search_tab.get("id") is not None:
+                categories.append(a_search_tab.get("id"))
+
+        return categories
+
+    @classmethod
+    def find(cls):
+        """
+        TODO: method to find a specific movie or tv series
+        """
+
+        raise NotImplementedError()
+
+    @classmethod
+    def __search_results(cls, html_page: BeautifulSoup, language: str) -> list:
+        search_results = []
+        for div_card in html_page.find_all('div', {'class': 'card v4 tight'}):
+            tmdb_entry = TMDbEntry(language=language)
+
+            div_title = div_card.find('div', {'class': 'title'})
+
+            if div_title.find('a') is not None:
+                tmdb_entry.category = div_title.find('a').get('data-media-type')
+
+            if div_title.find('a') is not None:
+                tmdb_entry.tmdb_id = re.search(r'(\d+)', div_title.find('a').get('href')).group()
+
+            if div_title.find('h2') is not None:
+                tmdb_entry.title = div_title.find('h2').get_text().replace('amp;', '')
+
+            if div_title.find('span') is not None:
+                tmdb_entry.release_year = re.search(r'(\d){4}', div_title.find('span').get_text()).group()
+
+            if div_card.find('p') is not None:
+                tmdb_entry.description = div_card.find('p').get_text()
+
+            if div_card.find('img') is not None:
+                tmdb_entry.poster_id = (re.search(r'(\w)+.jpg', div_card.find('img').get('src')).group()
+                                        .replace(".jpg", ""))
+
+            search_results.append(tmdb_entry)
+
+        return search_results
+
+    @classmethod
+    @cache
+    def search(cls, query: str = '', page: int = 1, language: str = "en",
+               recursive: bool = False, max_pages: int = 10) -> list:
+        """
+        Search for movies or tv series by their original, translated and alternative titles.
+        """
+
+        # build a search request for TMDb
+        path = f'/search'
+        query = f"language={language}&page={page}&query={query}"
+
+        # get response from TMDb request
+        response = Request.get(path=path, query=query)
+
+        # parse response to BeautifulSoup object
+        html_page = BeautifulSoup(response.text, features='html.parser')
+
+        # get search results from html page
+        search_results = cls.__search_results(html_page, language=language)
+
+        # if recursive is set, call search for every page after the current
+        if recursive and max_pages > 1:
+            if html_page.find('span', {'class': 'page next'}):
+                search_results += cls.search(query=query, page=page + 1, language=language,
+                                             recursive=True, max_pages=max_pages - 1)
+
+        return search_results
+
+    class Movie:
+        @classmethod
+        def poster_path(cls):
+            """
+            TODO: method to get the poster_path for a specific movie
+            """
+
+            raise NotImplementedError()
+
+    class TV:
+        @classmethod
+        def poster_path(cls):
+            """
+            TODO: method to get the poster_path for a specific tv series
+            """
+
+            raise NotImplementedError()
+
+        @classmethod
+        @cache
+        def seasons(cls, series_id: str) -> list:
+            # build a request for TMDb
+            path = f"/tv/{series_id}/seasons"
+
+            # get response from TMDb request
+            response = Request.get(path=path)
+
+            # parse response to BeautifulSoup object
+            html_page = BeautifulSoup(response.text, features="html.parser")
+
+            # extract seasons from HTML page
+            seasons = []
+            for season in html_page.find_all("div", {"class": "season_wrapper"}):
+                season_number = (re.search(r"season/(\d+)", season.find("h2").find("a").get("href")).group()
+                                 .replace("season/", ""))
+                seasons.append(season_number)
+
+            return seasons
+
+        @classmethod
+        def number_of_seasons(cls):
+            raise NotImplementedError()
+
+        @classmethod
+        @cache
+        def episodes(cls, series_id: str, season_id: str, language: str = "en") -> list:
+            # build a request for TMDb
+            path = f"/tv/{series_id}/season/{season_id}"
+            query = f"language={language}"
+
+            # get response from TMDb request
+            response = Request.get(path=path, query=query)
+
+            # parse response to BeautifulSoup object
+            html_page = BeautifulSoup(response.text, features="html.parser")
+
+            # extract episodes from HTML page
+            episodes = []
+            for div_card in html_page.find_all("div", {"class": "card"}):
+                episode_number = div_card.find("span", {'class': "episode_number"}).get_text()
+                episode_title = (div_card.find("div", {"class": "episode_title"}).find("a").get_text()
+                                 .replace("amp;", ""))
+                episodes.append({"number": episode_number, "title": episode_title})
+
+            return episodes
+
+
+class TMDbEntry:
+    def __init__(self, category: str = None, tmdb_id: str = None, title: str = None, release_year: str = None,
+                 description: str = None, poster_id: str = None, language: str = "en"):
+        self.category = category
+        self.tmdb_id = tmdb_id
+        self.title = title
+        self.release_year = release_year
+        self.description = description
+        self.poster_id = poster_id
+        self.language = language
+
+    def __str__(self):
+        if self.title is None:
+            return 'Not available'
+        if self.release_year is None:
+            return f'{self.title}'
+
+        return f'{self.title} ({self.release_year})'
+
+    def __eq__(self, other: "TMDbEntry") -> bool:
+        return (self.category == other.category
+                and self.tmdb_id == other.tmdb_id)
+
+    @property
+    def category(self) -> Optional[str]:
+        return self._category
+
+    @category.setter
+    def category(self, category: str = None) -> None:
+        if category is not None:
+            if not isinstance(category, str):
+                raise TypeError("TMDbEntry category must be a string.")
+
+            if category not in API.categories():
+                raise ValueError("TMDbEntry category must be 'movie' or 'tv'.")
+
+        self._category = category
+
+    @property
+    def tmdb_id(self) -> Optional[str]:
+        return self._tmdb_id
+
+    @tmdb_id.setter
+    def tmdb_id(self, tmdb_id: str = None) -> None:
+        if tmdb_id is not None:
+            if not isinstance(tmdb_id, str):
+                raise TypeError("TMDbEntry tmdb_id must be a string.")
+
+            if not tmdb_id.isnumeric():
+                raise ValueError("TMDbEntry tmdb_id must be numeric.")
+
+            if tmdb_id == "0":
+                raise ValueError("TMDbEntry tmdb_id must be greater than 0.")
+
+        self._tmdb_id = tmdb_id
+
+    @property
+    def title(self) -> Optional[str]:
+        return self._title
+
+    @title.setter
+    def title(self, title: str = None) -> None:
+        if title is not None:
+            if not isinstance(title, str):
+                raise TypeError("TMDbEntry title must be a string.")
+
+        self._title = title
+
+    @property
+    def release_year(self) -> Optional[str]:
+        return self._release_year
+
+    @release_year.setter
+    def release_year(self, release_year: str = None) -> None:
+        if release_year is not None:
+            if not isinstance(release_year, str):
+                raise TypeError("TMDbEntry release_year must be a string.")
+
+            if not release_year.isnumeric():
+                raise ValueError("TMDbEntry release_year must be numeric.")
+
+        self._release_year = release_year
+
+    @property
+    def description(self) -> Optional[str]:
+        return self._description
+
+    @description.setter
+    def description(self, description: str = None) -> None:
+        if description is not None:
+            if not isinstance(description, str):
+                raise TypeError("TMDbEntry description must be a string.")
+
+        self._description = description
+
+    @property
+    def poster_id(self) -> Optional[str]:
+        return self._poster_id
+
+    @poster_id.setter
+    def poster_id(self, poster_id: str = None) -> None:
+        if poster_id is not None:
+            if not isinstance(poster_id, str):
+                raise TypeError("TMDbEntry poster_id must be a string.")
+
+        self._poster_id = poster_id
+
+    @property
+    def language(self) -> Optional[str]:
+        return self._language
+
+    @language.setter
+    def language(self, language: str = None) -> None:
+        if language is not None:
+            if not isinstance(language, str):
+                raise TypeError("TMDbEntry language must be a string.")
+
+            if language not in API.languages():
+                raise ValueError(f"TMDbEntry language must be one of the following: {API.languages()}.")
+
+        self._language = language
+
+    def format_plex(self) -> str:
+        """
+        Formats a file name according to the Plex scheme.\n
+        https://support.plex.tv/articles/naming-and-organizing-your-movie-media-files/\n
+        https://support.plex.tv/articles/naming-and-organizing-your-tv-show-files/\n
+
+        :return: File name in Plex formatting.
+        """
+
+        if self.tmdb_id is None:
+            return f'{self}'
+
+        return f'{self} {{tmdb-{self.tmdb_id}}}'
+
+    def is_movie(self) -> bool:
+        """
+        Returns whether the entry is a movie.
+
+        :return: Is (not) a movie.
+        """
+        if self.category is None:
+            return False
+
+        return self.category == "movie"
+
+    def is_tv(self) -> bool:
+        """
+        Returns whether the entry is a TV show.
+
+        :return: Is (not) a TV show.
+        """
+        if self.category is None:
+            return False
+
+        return self.category == "tv"
+
+    def __poster_path(self, width: int, height: int) -> str:
+        return f"/t/p/w{width}_and_h{height}_bestv2/{self.poster_id}.jpg"
+
+    def poster(self, resolution: str = "low", high_resolution: bool = False) -> Optional[io.BytesIO]:
+        """
+        Returns the poster of this TMDbEntry. By default, with a resolution of 94x141.
+
+        :param resolution: Specify the desired resolution for the image (e.g. 'low', 'medium', 'high').
+        :parameter high_resolution: Specify whether the image should be returned in a higher resolution (600x900).
+        :return: Poster image.
+        """
+
+        if self.poster_id is None:
+            return None
+
+        if resolution != "low" and resolution != "medium" and resolution != "high":
+            raise ValueError("Specified resolution must be 'low', 'medium' or 'high'.")
+
+        if high_resolution:
+            resolution = "high"
+
+        if resolution == "low":
+            return Request.image(file_path=self.__poster_path(width=94, height=141))
+
+        if resolution == "medium":
+            return Request.image(file_path=self.__poster_path(width=188, height=282))
+
+        if resolution == "high":
+            return Request.image(file_path=self.__poster_path(width=600, height=900))
+
+    def get_poster(self, high_resolution: bool = False):
+        """
+        TODO: REMOVE THIS METHOD. NOW CALLABLE AS TMDbEntry.poster().\n
+
+        Returns the poster of this TMDbEntry. By default, with a resolution of 94x141.
+
+        :parameter high_resolution: Specify whether the image should be returned in a higher resolution (600x900).
+        :return: Poster image.
+        """
+
+        raise Exception("get_poster() HAS BEEN REMOVED. PLEASE USE TMDbEntry.poster().")
+
+    def seasons(self) -> list:
+        """
+        Returns a list of all seasons for a TV series.
+
+        :return: List of seasons.
+        """
+
+        # raise exception if TMDbEntry is not a TV series
+        if not self.is_tv():
+            raise Exception(f"TMDbEntry is not a TV series. Category: {self.category}")
+
+        return API.TV.seasons(series_id=self.tmdb_id)
+
+    def episodes(self, season_id: str) -> dict:
+        """
+        Returns a dictionary mapping all the episodes for a specific season.
+
+        :param season_id: The season id.
+        :return: Dictionary mapping the season´s episodes.
+        """
+
+        # raise exception if TMDbEntry is not a TV series
+        if not self.is_tv():
+            raise Exception(f"TMDbEntry is not a TV series. Category: {self.category}")
+
+        return API.TV.episodes(series_id=self.tmdb_id, season_id=season_id, language=self.language)
+
+    def season(self, season_id: str) -> dict:
+        """
+        TODO: REMOVE THIS METHOD. NOW CALLABLE AS TMDbEntry.episodes().\n
+
+        Returns a dictionary mapping all the episodes for a specific season.
+
+        :param season_id: The season id.
+        :return: Dictionary mapping the season´s episodes.
+        """
+
+        raise Exception("season() HAS BEEN REMOVED. PLEASE USE TMDbEntry.episodes().")

themoviedb-lib-0.0.1/tmdb/tests/test_tmdb_api.py

@@ -0,0 +1,80 @@
+import unittest
+
+from .. import *
+
+
+class TestTMDbAPI(unittest.TestCase):
+
+    # tests for languages()
+    def test_languages_iso_639(self):
+        """ Check whether language tags match the ISO-639-1 standard."""
+
+        languages = API.languages()
+
+        for language in languages:
+            self.assertTrue(re.fullmatch(r"[a-z]{2}", language))
+
+    def test_languages_iso_639_no_duplicates(self):
+        """ Check that there are no duplicate language tags."""
+
+        languages = API.languages()
+
+        for language in languages:
+            languages.remove(language)
+            self.assertFalse(language in languages)
+
+    def test_languages_iso_639_cantonese(self):
+        """ Cantonese ("cn") is not included in the ISO-639-1 standard. """
+
+        languages = API.languages()
+
+        self.assertFalse("cn" in languages)
+
+    def test_languages_ietf(self):
+        """ Check whether language tags match the IETF standard."""
+
+        languages = API.languages(iso_639=False)
+
+        for language in languages:
+            self.assertTrue(re.fullmatch(r"[a-z]{2}-[A-Z]{2}", language))
+
+    def test_languages_ietf_no_duplicates(self):
+        """ Check that there are no duplicate language tags."""
+
+        languages = API.languages(iso_639=False)
+
+        for language in languages:
+            languages.remove(language)
+            self.assertFalse(language in languages)
+
+    # tests for categories()
+    def test_categories(self):
+        categories = API.categories()
+        categories_reference = ['movie', 'tv', 'person', 'collection', 'company', 'keyword', 'network']
+
+        self.assertEqual(categories_reference, categories)
+
+    # tests for search()
+    def test_search(self):
+        search_results = API.search(query="Star Wars")
+        tmdb_entry = TMDbEntry(category="movie", tmdb_id="11")
+
+        self.assertTrue(tmdb_entry in search_results)
+
+    # tests for TV.seasons()
+    def test_TV_seasons(self):
+        seasons = API.TV.seasons(series_id="253")
+        seasons_reference = ['0', '1', '2', '3']
+
+        self.assertEqual(seasons_reference, seasons)
+
+    # tests for TV.episodes()
+    def test_TV_episodes(self):
+        episodes = API.TV.episodes(series_id="253", season_id="1")
+        episodes_reference = [{'number': '1', 'title': 'The Man Trap'}, {'number': '2', 'title': 'Charlie X'}, {'number': '3', 'title': 'Where No Man Has Gone Before'}, {'number': '4', 'title': 'The Naked Time'}, {'number': '5', 'title': 'The Enemy Within'}, {'number': '6', 'title': "Mudd's Women"}, {'number': '7', 'title': 'What Are Little Girls Made Of?'}, {'number': '8', 'title': 'Miri'}, {'number': '9', 'title': 'Dagger of the Mind'}, {'number': '10', 'title': 'The Corbomite Maneuver'}, {'number': '11', 'title': 'The Menagerie (1)'}, {'number': '12', 'title': 'The Menagerie (2)'}, {'number': '13', 'title': 'The Conscience of the King'}, {'number': '14', 'title': 'Balance of Terror'}, {'number': '15', 'title': 'Shore Leave'}, {'number': '16', 'title': 'The Galileo Seven'}, {'number': '17', 'title': 'The Squire of Gothos'}, {'number': '18', 'title': 'Arena'}, {'number': '19', 'title': 'Tomorrow Is Yesterday'}, {'number': '20', 'title': 'Court Martial'}, {'number': '21', 'title': 'The Return of the Archons'}, {'number': '22', 'title': 'Space Seed'}, {'number': '23', 'title': 'A Taste of Armageddon'}, {'number': '24', 'title': 'This Side of Paradise'}, {'number': '25', 'title': 'The Devil in the Dark'}, {'number': '26', 'title': 'Errand of Mercy'}, {'number': '27', 'title': 'The Alternative Factor'}, {'number': '28', 'title': 'The City on the Edge of Forever'}, {'number': '29', 'title': 'Operation: Annihilate!'}]
+
+        self.assertEqual(episodes_reference, episodes)
+
+
+if __name__ == '__main__':
+    unittest.main()

themoviedb-lib-0.0.1/tmdb/tests/test_tmdb_entry.py

@@ -0,0 +1,302 @@
+import unittest
+from .. import *
+
+
+class TestTMDbEntry(unittest.TestCase):
+
+    # tests for __str__()
+    def test_string_representation(self):
+        tmdb_entry = TMDbEntry(title="The Movie", release_year="2024")
+
+        self.assertEqual("The Movie (2024)", str(tmdb_entry))
+
+    def test_string_representation_no_release_year(self):
+        tmdb_entry = TMDbEntry(title="The Movie")
+
+        self.assertEqual("The Movie", str(tmdb_entry))
+
+    def test_string_representation_no_title(self):
+        tmdb_entry = TMDbEntry(release_year="2024")
+
+        self.assertEqual("Not available", str(tmdb_entry))
+
+    def test_string_representation_no_release_year_and_title(self):
+        tmdb_entry = TMDbEntry()
+
+        self.assertEqual("Not available", str(tmdb_entry))
+
+    # tests for __eq__()
+    def test_equals_same_entry(self):
+        tmdb_entry_1 = TMDbEntry(category="movie", tmdb_id="1")
+        tmdb_entry_2 = TMDbEntry(category="movie", tmdb_id="1")
+
+        self.assertEqual(tmdb_entry_1, tmdb_entry_2)
+
+    def test_equals_different_category(self):
+        tmdb_entry_1 = TMDbEntry(category="movie", tmdb_id="1")
+        tmdb_entry_2 = TMDbEntry(category="tv", tmdb_id="1")
+
+        self.assertNotEqual(tmdb_entry_1, tmdb_entry_2)
+
+    def test_equals_different_tmdb_id(self):
+        tmdb_entry_1 = TMDbEntry(category="movie", tmdb_id="1")
+        tmdb_entry_2 = TMDbEntry(category="movie", tmdb_id="2")
+
+        self.assertNotEqual(tmdb_entry_1, tmdb_entry_2)
+
+    def test_equals_empty_entry(self):
+        tmdb_entry_1 = TMDbEntry()
+        tmdb_entry_2 = TMDbEntry()
+
+        self.assertEqual(tmdb_entry_1, tmdb_entry_2)
+
+    # tests for category attribute
+    def test_category_movie(self):
+        tmdb_entry = TMDbEntry(category="movie")
+
+        self.assertEqual("movie", tmdb_entry.category)
+
+    def test_category_tv(self):
+        tmdb_entry = TMDbEntry(category="tv")
+
+        self.assertEqual("tv", tmdb_entry.category)
+
+    def test_category_invalid_category(self):
+        self.assertRaises(ValueError, lambda: TMDbEntry(category="invalid_category"))
+
+    def test_category_invalid_type(self):
+        self.assertRaises(TypeError, lambda: TMDbEntry(category=0))
+
+    def test_category_none(self):
+        tmdb_entry = TMDbEntry(category=None)
+
+        self.assertIsNone(tmdb_entry.category)
+
+    # tests for tmdb id attribute
+    def test_tmdb_id_number(self):
+        for x in range(1, 100, 5):
+            tmdb_entry = TMDbEntry(tmdb_id=str(x))
+            self.assertEqual(str(x), tmdb_entry.tmdb_id)
+
+    def test_tmdb_id_invalid_type(self):
+        self.assertRaises(TypeError, lambda: TMDbEntry(tmdb_id=0))
+
+    def test_tmdb_id_non_numeric(self):
+        self.assertRaises(ValueError, lambda: TMDbEntry(tmdb_id="x"))
+
+    def test_tmdb_id_negative_number(self):
+        self.assertRaises(ValueError, lambda: TMDbEntry(tmdb_id="-1"))
+
+    def test_tmdb_id_zero(self):
+        self.assertRaises(ValueError, lambda: TMDbEntry(tmdb_id="0"))
+
+    def test_tmdb_id_none(self):
+        tmdb_entry = TMDbEntry(tmdb_id=None)
+
+        self.assertIsNone(tmdb_entry.tmdb_id)
+
+    # tests for title attribute
+    def test_title_string(self):
+        tmdb_entry = TMDbEntry(title="The Movie")
+
+        self.assertEqual("The Movie", tmdb_entry.title)
+
+    def test_title_invalid_type(self):
+        self.assertRaises(TypeError, lambda: TMDbEntry(title=0))
+
+    def test_title_none(self):
+        tmdb_entry = TMDbEntry(title=None)
+
+        self.assertIsNone(tmdb_entry.title)
+
+    # tests for release_year attribute
+    def test_release_year_number(self):
+        tmdb_entry = TMDbEntry(release_year="2024")
+
+        self.assertEqual("2024", tmdb_entry.release_year)
+
+    def test_release_year_invalid_type(self):
+        self.assertRaises(TypeError, lambda: TMDbEntry(release_year=0))
+
+    def test_release_year_non_numeric(self):
+        self.assertRaises(ValueError, lambda: TMDbEntry(release_year="x"))
+
+    def test_release_year_none(self):
+        tmdb_entry = TMDbEntry(release_year=None)
+
+        self.assertIsNone(tmdb_entry.release_year)
+
+    # tests for description attribute
+    def test_description_string(self):
+        tmdb_entry = TMDbEntry(description="The Movie")
+
+        self.assertEqual("The Movie", tmdb_entry.description)
+
+    def test_description_invalid_type(self):
+        self.assertRaises(TypeError, lambda: TMDbEntry(description=0))
+
+    def test_description_none(self):
+        tmdb_entry = TMDbEntry(description=None)
+
+        self.assertIsNone(tmdb_entry.description)
+
+    # tests for poster_id attribute
+    def test_poster_id_string(self):
+        tmdb_entry = TMDbEntry(poster_id="mqGTDn6c5wy4Bwf6DR7eZeO7c5d")
+
+        self.assertEqual("mqGTDn6c5wy4Bwf6DR7eZeO7c5d", tmdb_entry.poster_id)
+
+    def test_poster_id_invalid_type(self):
+        self.assertRaises(TypeError, lambda: TMDbEntry(poster_id=0))
+
+    def test_poster_id_none(self):
+        tmdb_entry = TMDbEntry(poster_id=None)
+
+        self.assertIsNone(tmdb_entry.poster_id)
+
+    # tests for language attribute
+    def test_language_string(self):
+        tmdb_entry = TMDbEntry(language="en")
+
+        self.assertEqual("en", tmdb_entry.language)
+
+    def test_language_invalid_type(self):
+        self.assertRaises(TypeError, lambda: TMDbEntry(language=0))
+
+    def test_language_invalid_language_tag(self):
+        self.assertRaises(ValueError, lambda: TMDbEntry(language="roman"))
+
+    def test_language_none(self):
+        tmdb_entry = TMDbEntry(language=None)
+
+        self.assertIsNone(tmdb_entry.language)
+
+    # tests for format_plex()
+    def test_format_plex_string_representation(self):
+        tmdb_entry = TMDbEntry(tmdb_id="1", title="The Movie", release_year="2024")
+
+        self.assertEqual("The Movie (2024) {tmdb-1}", tmdb_entry.format_plex())
+
+    def test_format_plex_string_representation_no_release_year(self):
+        tmdb_entry = TMDbEntry(tmdb_id="1", title="The Movie")
+
+        self.assertEqual("The Movie {tmdb-1}", tmdb_entry.format_plex())
+
+    def test_format_plex_string_representation_no_title(self):
+        tmdb_entry = TMDbEntry(tmdb_id="1", release_year="2024")
+
+        self.assertEqual("Not available {tmdb-1}", tmdb_entry.format_plex())
+
+    def test_format_plex_string_representation_no_release_year_and_title(self):
+        tmdb_entry = TMDbEntry(tmdb_id="1")
+
+        self.assertEqual("Not available {tmdb-1}", tmdb_entry.format_plex())
+
+    def test_format_plex_string_representation_no_tmdb_id(self):
+        tmdb_entry = TMDbEntry(title="The Movie", release_year="2024")
+
+        self.assertEqual("The Movie (2024)", tmdb_entry.format_plex())
+
+    def test_format_plex_string_representation_no_tmdb_id_and_release_year(self):
+        tmdb_entry = TMDbEntry(title="The Movie")
+
+        self.assertEqual("The Movie", tmdb_entry.format_plex())
+
+    def test_format_plex_string_representation_no_tmdb_id_and_title(self):
+        tmdb_entry = TMDbEntry(release_year="2024")
+
+        self.assertEqual("Not available", tmdb_entry.format_plex())
+
+    def test_format_plex_string_representation_no_tmdb_id_and_release_year_and_title(self):
+        tmdb_entry = TMDbEntry()
+
+        self.assertEqual("Not available", tmdb_entry.format_plex())
+
+    # tests for is_movie()
+    def test_is_movie_for_category_movie(self):
+        tmdb_entry = TMDbEntry(category="movie")
+
+        self.assertTrue(tmdb_entry.is_movie())
+
+    def test_is_movie_for_category_tv(self):
+        tmdb_entry = TMDbEntry(category="tv")
+
+        self.assertFalse(tmdb_entry.is_movie())
+
+    def test_is_movie_for_category_none(self):
+        tmdb_entry = TMDbEntry(category=None)
+
+        self.assertFalse(tmdb_entry.is_movie())
+
+    # tests for is_tv()
+    def test_is_tv_for_category_tv(self):
+        tmdb_entry = TMDbEntry(category="tv")
+
+        self.assertTrue(tmdb_entry.is_tv())
+
+    def test_is_tv_for_category_movie(self):
+        tmdb_entry = TMDbEntry(category="movie")
+
+        self.assertFalse(tmdb_entry.is_tv())
+
+    def test_is_tv_for_category_none(self):
+        tmdb_entry = TMDbEntry(category=None)
+
+        self.assertFalse(tmdb_entry.is_tv())
+
+    # tests for poster()
+    def test_poster_default_resolution(self):
+        tmdb_entry = TMDbEntry(poster_id="mqGTDn6c5wy4Bwf6DR7eZeO7c5d")
+
+        self.assertIsInstance(tmdb_entry.poster(), io.BytesIO)
+
+    def test_poster_low_resolution(self):
+        tmdb_entry = TMDbEntry(poster_id="mqGTDn6c5wy4Bwf6DR7eZeO7c5d")
+
+        self.assertIsInstance(tmdb_entry.poster(resolution="low"), io.BytesIO)
+
+    def test_poster_medium_resolution(self):
+        tmdb_entry = TMDbEntry(poster_id="mqGTDn6c5wy4Bwf6DR7eZeO7c5d")
+
+        self.assertIsInstance(tmdb_entry.poster(resolution="medium"), io.BytesIO)
+
+    def test_poster_high_resolution(self):
+        tmdb_entry = TMDbEntry(poster_id="mqGTDn6c5wy4Bwf6DR7eZeO7c5d")
+
+        self.assertIsInstance(tmdb_entry.poster(resolution="high"), io.BytesIO)
+
+    def test_poster_poster_id_is_none(self):
+        tmdb_entry = TMDbEntry(poster_id=None)
+
+        self.assertIsNone(tmdb_entry.poster())
+
+    def test_poster_invalid_resolution(self):
+        tmdb_entry = TMDbEntry(poster_id="mqGTDn6c5wy4Bwf6DR7eZeO7c5d")
+
+        self.assertRaises(ValueError, lambda: tmdb_entry.poster(resolution="ultra-high"))
+
+    # tests for seasons()
+    def test_seasons(self):
+        tmdb_entry = TMDbEntry(category="tv", tmdb_id="253")
+        seasons_reference = ['0', '1', '2', '3']
+
+        self.assertEqual(seasons_reference, tmdb_entry.seasons())
+
+    def test_seasons_movie(self):
+        tmdb_entry = TMDbEntry(category="movie", tmdb_id="11")
+        self.assertRaises(Exception, lambda: tmdb_entry.seasons())
+
+    # tests for episodes()
+    def test_episodes(self):
+        tmdb_entry = TMDbEntry(category="tv", tmdb_id="253")
+        episodes_reference = [{'number': '1', 'title': 'The Man Trap'}, {'number': '2', 'title': 'Charlie X'}, {'number': '3', 'title': 'Where No Man Has Gone Before'}, {'number': '4', 'title': 'The Naked Time'}, {'number': '5', 'title': 'The Enemy Within'}, {'number': '6', 'title': "Mudd's Women"}, {'number': '7', 'title': 'What Are Little Girls Made Of?'}, {'number': '8', 'title': 'Miri'}, {'number': '9', 'title': 'Dagger of the Mind'}, {'number': '10', 'title': 'The Corbomite Maneuver'}, {'number': '11', 'title': 'The Menagerie (1)'}, {'number': '12', 'title': 'The Menagerie (2)'}, {'number': '13', 'title': 'The Conscience of the King'}, {'number': '14', 'title': 'Balance of Terror'}, {'number': '15', 'title': 'Shore Leave'}, {'number': '16', 'title': 'The Galileo Seven'}, {'number': '17', 'title': 'The Squire of Gothos'}, {'number': '18', 'title': 'Arena'}, {'number': '19', 'title': 'Tomorrow Is Yesterday'}, {'number': '20', 'title': 'Court Martial'}, {'number': '21', 'title': 'The Return of the Archons'}, {'number': '22', 'title': 'Space Seed'}, {'number': '23', 'title': 'A Taste of Armageddon'}, {'number': '24', 'title': 'This Side of Paradise'}, {'number': '25', 'title': 'The Devil in the Dark'}, {'number': '26', 'title': 'Errand of Mercy'}, {'number': '27', 'title': 'The Alternative Factor'}, {'number': '28', 'title': 'The City on the Edge of Forever'}, {'number': '29', 'title': 'Operation: Annihilate!'}]
+
+        self.assertEqual(episodes_reference, tmdb_entry.episodes(season_id="1"))
+
+    def test_episodes_movie(self):
+        tmdb_entry = TMDbEntry(category="movie", tmdb_id="11")
+        self.assertRaises(Exception, lambda: tmdb_entry.episodes(season_id="1"))
+
+
+if __name__ == '__main__':
+    unittest.main()

themoviedb-lib-0.0.1/tmdb/tests/test_tmdb_request.py

@@ -0,0 +1,50 @@
+import unittest
+
+from .. import *
+
+
+class TestTMDbRequest(unittest.TestCase):
+
+    # tests for the get() method
+    def test_response(self):
+        """ Check whether the get() method returns a requests.models.Response instance. """
+
+        response = Request.get()
+
+        self.assertIsInstance(response, requests.models.Response)
+
+    def test_home_page(self):
+        """ Check whether the TMDb home page <www.themoviedb.org> can be retrieved. """
+
+        response = Request.get()
+
+        self.assertTrue(response)
+
+    def test_search_page(self):
+        """ Check whether the TMDb search page <www.themoviedb.org/search> can be retrieved. """
+
+        response = Request.get(path="/search")
+
+        self.assertTrue(response)
+
+    def test_invalid_page(self):
+        """ Check whether requesting invalid TMDb pages <www.themoviedb.org/invalid_error_xy> throws an exception. """
+
+        self.assertRaises(Exception, lambda: Request.get(path="/invalid_error_xy"))
+
+    # tests for the image() method
+    def test_download_image(self):
+        """ Check whether the image() method returns an io.BytesIO instance. """
+        file_path = "/t/p/w94_and_h141_bestv2/6FfCtAuVAW8XJjZ7eWeLibRLWTw.jpg"
+
+        self.assertIsInstance(Request.image(file_path=file_path), io.BytesIO)
+
+    def test_invalid_image(self):
+        """ Check whether the image() method returns an io.BytesIO instance. """
+        file_path = "/t/p/w94_and_h141_bestv2/invalid_image.jpg"
+
+        self.assertRaises(Exception, lambda: Request.image(file_path=file_path))
+
+
+if __name__ == '__main__':
+    unittest.main()