showtime-cli 0.3.25__tar.gz → 0.3.27__tar.gz

{showtime_cli-0.3.25 → showtime_cli-0.3.27}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: showtime-cli
-Version: 0.3.25
+Version: 0.3.27
 Summary: Command line show tracker using the TVMaze public API
 Author-email: Evgeniy Vasilev <aquilax@gmail.com>
 License: MIT
@@ -18,7 +18,7 @@ Classifier: Topic :: Utilities
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: cmd2==4.2.2
+Requires-Dist: cmd2==4.2.4
 Requires-Dist: ratelimit==2.2.1
 Requires-Dist: tinydb==4.9.0
 Requires-Dist: terminaltables==3.1.10
@@ -37,10 +37,39 @@ Dynamic: license-file
 
 # showtime
 
-Small command line interactive tv show tracker using the TvMaze API.
+Small command line tracker for TV series using TVMaze and movies using TMDB.
 
 ## Installation
 
 ```sh
 pip install showtime-cli
 ```
+
+## Movies
+
+Movie search and add use TMDB. Set a TMDB API Read Access Token with
+`TMDB_ACCESS_TOKEN`, or add it to `~/.showtime.ini`:
+
+```ini
+[TMDB]
+AccessToken = your-tmdb-read-access-token
+```
+
+The token is needed for `movie_search`, `movie_add`, and IMDb imports. Movie
+tracking and watched status are stored locally:
+
+```text
+movie_search <query>
+movie_add <tmdb_id>
+movie_add_watched <tmdb_id>
+movie_remove <tmdb_id>
+movies [query]
+movie_watch <tmdb_id>
+movie_unwatch <tmdb_id>
+movie_import_imdb_ratings <filename>
+```
+
+IMDb imports read the `Const`, `Your Rating`, `Date Rated`, and `Title Type`
+columns. Movie and TV Movie rows are resolved through TMDB, added if needed,
+and marked watched on their IMDb rating date. Other title types and unresolved
+IMDb IDs are skipped.

showtime_cli-0.3.27/README.md

@@ -0,0 +1,38 @@
+# showtime
+
+Small command line tracker for TV series using TVMaze and movies using TMDB.
+
+## Installation
+
+```sh
+pip install showtime-cli
+```
+
+## Movies
+
+Movie search and add use TMDB. Set a TMDB API Read Access Token with
+`TMDB_ACCESS_TOKEN`, or add it to `~/.showtime.ini`:
+
+```ini
+[TMDB]
+AccessToken = your-tmdb-read-access-token
+```
+
+The token is needed for `movie_search`, `movie_add`, and IMDb imports. Movie
+tracking and watched status are stored locally:
+
+```text
+movie_search <query>
+movie_add <tmdb_id>
+movie_add_watched <tmdb_id>
+movie_remove <tmdb_id>
+movies [query]
+movie_watch <tmdb_id>
+movie_unwatch <tmdb_id>
+movie_import_imdb_ratings <filename>
+```
+
+IMDb imports read the `Const`, `Your Rating`, `Date Rated`, and `Title Type`
+columns. Movie and TV Movie rows are resolved through TMDB, added if needed,
+and marked watched on their IMDb rating date. Other title types and unresolved
+IMDb IDs are skipped.

{showtime_cli-0.3.25 → showtime_cli-0.3.27}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "showtime-cli"
-version = "0.3.25"
+version = "0.3.27"
 description = "Command line show tracker using the TVMaze public API"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -22,7 +22,7 @@ classifiers = [
     "Topic :: Utilities",
 ]
 dependencies = [
-    "cmd2==4.2.2",
+    "cmd2==4.2.4",
     "ratelimit==2.2.1",
     "tinydb==4.9.0",
     "terminaltables==3.1.10",

showtime_cli-0.3.27/showtime/__init__.py

@@ -0,0 +1,12 @@
+"""Common module information"""
+
+from importlib.metadata import version, PackageNotFoundError
+
+__version__ = 'unknown'
+__url__ = 'https://github.com/aquilax/showtime'
+
+try:
+    __version__ = version("your_package_name")
+except PackageNotFoundError:
+    pass
+

showtime_cli-0.3.27/showtime/api.py

@@ -0,0 +1,160 @@
+"""API client module"""
+
+from dataclasses import dataclass
+import json
+from urllib.parse import urlencode, urlparse, urlunparse
+import urllib.request
+from typing import Any, Dict, List, Optional
+
+from ratelimit import limits, sleep_and_retry
+
+from showtime.types import MovieId, ShowId, TMDBMovie, TVMazeEpisode, TVMazeShow
+
+API_BASE_URL = "https://api.tvmaze.com"
+TMDB_API_BASE_URL = "https://api.themoviedb.org/3"
+
+
+def episode_to_model(episode: Dict) -> TVMazeEpisode:
+    return TVMazeEpisode(
+        id=episode['id'],
+        season=episode['season'],
+        number=episode['number'],
+        name=episode['name'],
+        airdate=episode['airdate'],
+        runtime=episode['runtime'],
+    )
+
+
+def show_to_model(show: Dict) -> TVMazeShow:
+    return TVMazeShow(
+        id=show['id'],
+        name=show['name'],
+        premiered=show['premiered'],
+        status=show['status'],
+        url=show['url'],
+        externals=show['externals']
+    )
+
+
+def search_to_model(show_wrapped) -> TVMazeShow:
+    return show_to_model(show_wrapped['show'])
+
+
+def movie_to_model(movie: Dict) -> TMDBMovie:
+    return TMDBMovie(
+        id=movie['id'],
+        title=movie['title'],
+        release_date=movie.get('release_date') or None,
+        runtime=movie.get('runtime'),
+        original_language=movie.get('original_language'),
+    )
+
+
+@dataclass
+class HTTPResponse:
+    data: bytes
+
+
+class HTTPClient():
+    """HTTP Client"""
+
+    def request(self, _method: str, url: str, fields: Optional[dict[str, str]]=None,
+                headers: Optional[dict[str, str]]=None) -> Any:
+        request_headers = {
+            "User-Agent": "showtime-cli",
+            "Accept": "application/json"
+        }
+        if headers:
+            request_headers.update(headers)
+
+        url_parts = list(urlparse(url))
+        url_parts[4] = urlencode(fields or {})
+        final_url = urlunparse(url_parts)
+        request = urllib.request.Request(final_url, headers=request_headers)
+        with urllib.request.urlopen(request) as response:
+            return HTTPResponse(data=response.read())
+
+
+class Api():
+    """API Client"""
+
+    def __init__(self, http: HTTPClient, tmdb_access_token: Optional[str]=None) -> None:
+        self.http = http
+        self.tmdb_access_token = tmdb_access_token
+
+    def _tmdb_headers(self) -> dict[str, str]:
+        if not self.tmdb_access_token:
+            raise RuntimeError(
+                "TMDB access token is required. Set TMDB_ACCESS_TOKEN or TMDB.AccessToken in your config."
+            )
+        return {"Authorization": f"Bearer {self.tmdb_access_token}"}
+
+    @sleep_and_retry
+    @limits(calls=20, period=10)
+    def _tmdb_request(self, url: str, fields: Optional[dict[str, str]]=None) -> Any:
+        """Makes a rate-limited TMDB request"""
+        headers = self._tmdb_headers()
+        if fields is None:
+            return self.http.request('GET', url, headers=headers)
+        return self.http.request('GET', url, fields=fields, headers=headers)
+
+    @sleep_and_retry
+    @limits(calls=20, period=10)
+    def _tvmaze_request(self, url: str, fields: Optional[dict[str, str]]=None) -> Any:
+        """Makes a rate-limited TVMaze request"""
+        if fields is None:
+            return self.http.request('GET', url)
+        return self.http.request('GET', url, fields=fields)
+
+    def episodes_list(self, show_id: ShowId) -> List[TVMazeEpisode]:
+        """returns list of episodes for a show"""
+        response = self._tvmaze_request(f"{API_BASE_URL}/shows/{show_id}/episodes")
+        raw_episodes = json.loads(response.data.decode('utf-8'))
+        return list(map(episode_to_model, raw_episodes))
+
+    def show_get(self, show_id: ShowId) -> Optional[TVMazeShow]:
+        """returns show information"""
+        response = self._tvmaze_request(f"{API_BASE_URL}/shows/{show_id}")
+        raw_show = json.loads(response.data.decode('utf-8'))
+        return show_to_model(raw_show)
+
+    def show_search(self, query: str) -> List[TVMazeShow]:
+        """returns list of shows matching search string"""
+        response = self._tvmaze_request(f"{API_BASE_URL}/search/shows", fields={'q': query})
+        raw_shows = json.loads(response.data.decode('utf-8'))
+        return list(map(search_to_model, raw_shows))
+
+    def movie_search(self, query: str) -> List[TMDBMovie]:
+        """Returns movies matching the search string"""
+        response = self._tmdb_request(
+            f"{TMDB_API_BASE_URL}/search/movie", fields={'query': query, 'include_adult': 'true'}
+        )
+        raw_movies = json.loads(response.data.decode('utf-8'))
+        return list(map(movie_to_model, raw_movies['results']))
+
+    def movie_get(self, movie_id: MovieId) -> TMDBMovie:
+        """Returns movie information"""
+        response = self._tmdb_request(f"{TMDB_API_BASE_URL}/movie/{movie_id}")
+        raw_movie = json.loads(response.data.decode('utf-8'))
+        return movie_to_model(raw_movie)
+
+    def movie_external_ids(self, movie_id: MovieId) -> Dict[str, Optional[str]]:
+        """Returns all external identifiers for a TMDB movie"""
+        response = self._tmdb_request(f"{TMDB_API_BASE_URL}/movie/{movie_id}/external_ids")
+        raw_ids = json.loads(response.data.decode('utf-8'))
+        return {key: value for key, value in raw_ids.items() if key != 'id'}
+
+    def movie_find_by_imdb_id(self, imdb_id: str) -> Optional[MovieId]:
+        """Returns the TMDB movie ID matching an IMDb identifier"""
+        response = self._tmdb_request(
+            f"{TMDB_API_BASE_URL}/find/{imdb_id}", fields={'external_source': 'imdb_id'}
+        )
+        result = json.loads(response.data.decode('utf-8'))
+        movies = result.get('movie_results', [])
+        return MovieId(movies[0]['id']) if movies else None
+
+
+def get_default_pool_manager():
+    return HTTPClient()
+
+