showtime-cli 0.3.24__tar.gz → 0.3.26__tar.gz

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: showtime-cli
-Version: 0.3.24
+Version: 0.3.26
 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.1
+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.26/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.24 → showtime_cli-0.3.26}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "showtime-cli"
-version = "0.3.24"
+version = "0.3.26"
 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.1",
+    "cmd2==4.2.4",
     "ratelimit==2.2.1",
     "tinydb==4.9.0",
     "terminaltables==3.1.10",

showtime_cli-0.3.26/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()
+
+

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/showtime/command.py

@@ -15,12 +15,13 @@ from showtime.config import Config
 from showtime.database import get_cashed_write_db, get_memory_db
 from showtime.output import Output
 from showtime.showtime import ShowtimeApp
-from showtime.types import Episode, EpisodeId, Show, ShowId
+from showtime.types import Episode, EpisodeId, MovieId, Show, ShowId
 
 from . import __version__
 
 SHOW_CATEGORY = 'Show management'
 EPISODE_CATEGORY = 'Episode management'
+MOVIE_CATEGORY = 'Movie management'
 
 
 class Showtime(Cmd):
@@ -90,6 +91,83 @@ class Showtime(Cmd):
         search_result_table = self.output.format_search_results(search_result)
         self.output.poutput(search_result_table)
 
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movie_search(self, statement: Statement) -> None:
+        """Search TMDB for movies [movie_search <query>]"""
+        try:
+            search_result = self.app.movie_search_api(statement)
+        except RuntimeError as error:
+            self.output.perror(str(error))
+            return
+        self.output.poutput(self.output.format_movie_search_results(search_result))
+
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movie_add(self, statement: Statement) -> None:
+        """Add a movie from TMDB [movie_add <tmdb_id>]"""
+        try:
+            movie = self.app.movie_add(MovieId(statement))
+        except RuntimeError as error:
+            self.output.perror(str(error))
+            return
+        self.output.poutput(f"Added movie: ({movie.id}) {movie.title}")
+
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movie_add_watched(self, statement: Statement) -> None:
+        """Add a movie and mark it watched [movie_add_watched <tmdb_id>]"""
+        try:
+            movie = self.app.movie_add_watched(MovieId(statement), self._get_current_datetime())
+        except RuntimeError as error:
+            self.output.perror(str(error))
+            return
+        self.output.poutput(f"Added and marked as watched: ({movie.id}) {movie.title}")
+
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movie_remove(self, statement: Statement) -> None:
+        """Remove a tracked movie [movie_remove <tmdb_id>]"""
+        movie_id = MovieId(statement)
+        movie = self.app.movie_get(movie_id)
+        if not movie:
+            self.output.perror(f'Movie {movie_id} not found')
+            return
+        self.app.movie_remove(movie_id)
+        self.output.poutput(f"Removed movie: ({movie_id}) {movie['title']}")
+
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movies(self, query: Statement) -> None:
+        """Show tracked movies [movies <query>]"""
+        movies = self.app.movie_search(query)
+        self.output.ppaged(self.output.movies_table(movies))
+
+    def _set_movie_watched(self, statement: Statement, watched: bool) -> None:
+        movie_id = MovieId(statement)
+        movie = self.app.movie_get(movie_id)
+        if not movie:
+            self.output.perror(f'Movie {movie_id} not found')
+            return
+        self.app.movie_update_watched(movie_id, watched, self._get_current_datetime())
+
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movie_watch(self, statement: Statement) -> None:
+        """Mark a movie as watched [movie_watch <tmdb_id>]"""
+        self._set_movie_watched(statement, True)
+
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movie_unwatch(self, statement: Statement) -> None:
+        """Mark a movie as unwatched [movie_unwatch <tmdb_id>]"""
+        self._set_movie_watched(statement, False)
+
+    @cmd2.with_category(MOVIE_CATEGORY)
+    def do_movie_import_imdb_ratings(self, file_name: Statement) -> None:
+        """Import watched movies from an IMDb ratings export [movie_import_imdb_ratings <filename>]"""
+        try:
+            imported, skipped = self.app.import_imdb_ratings(
+                str(file_name), on_progress=self.output.pfeedback
+            )
+        except (OSError, RuntimeError, ValueError) as error:
+            self.output.perror(str(error))
+            return
+        self.output.poutput(f"Imported {imported} movie ratings; skipped {skipped} rows")
+
     @cmd2.with_category(SHOW_CATEGORY)
     def do_follow(self, statement: Statement) -> None:
         """Follow show(s) by id [follow <show_id>[,<show_id>...]]"""
@@ -364,9 +442,9 @@ class Showtime(Cmd):
 
 
 def main() -> None:
-    api = Api(get_default_pool_manager())
     config = Config()
     config.load()
+    api = Api(get_default_pool_manager(), tmdb_access_token=config.get('TMDB', 'AccessToken') or None)
     dry_run = os.getenv('SHOWTIME_DRY_RUN') is not None
     database_filename = config.get('Database', 'Path')
     database = get_memory_db() if dry_run else get_cashed_write_db(database_filename)

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/showtime/config.py

@@ -19,6 +19,9 @@ class Config(ConfigParser):
         self.add_section('History')
         self.set('History', 'Path', str(os.path.expanduser('~/.showtime_history')))
 
+        self.add_section('TMDB')
+        self.set('TMDB', 'AccessToken', '')
+
         if file_name == '':
             for location in self.common_locations:
                 if os.path.exists(location):
@@ -26,3 +29,7 @@ class Config(ConfigParser):
 
         if file_name:
             self.read(file_name)
+
+        tmdb_access_token = os.getenv('TMDB_ACCESS_TOKEN')
+        if tmdb_access_token:
+            self.set('TMDB', 'AccessToken', tmdb_access_token)

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/showtime/database.py

@@ -2,7 +2,7 @@
 
 from contextlib import contextmanager
 from datetime import date, datetime
-from typing import (Iterator, Tuple, Dict, Generator, List,  Optional, cast)
+from typing import (Any, Iterator, Tuple, Dict, Generator, List,  Optional, cast)
 
 import dateutil.parser
 from tinydb import TinyDB, where
@@ -10,11 +10,12 @@ from tinydb.middlewares import CachingMiddleware
 from tinydb.queries import QueryLike
 from tinydb.storages import JSONStorage, MemoryStorage
 
-from showtime.types import (Episode, EpisodeId, Show, ShowId, ShowStatus,
-                            TVMazeEpisode, TVMazeShow, ShowWithCount)
+from showtime.types import (Episode, EpisodeId, Movie, MovieId, Show, ShowId, ShowStatus,
+                            TMDBMovie, TVMazeEpisode, TVMazeShow, ShowWithCount)
 
 SHOW = 'show'
 EPISODE = 'episode'
+MOVIE = 'movie'
 
 NOT_WATCHED_VALUE = ''
 
@@ -67,6 +68,49 @@ class Database(TinyDB):
         })
         return EpisodeId(episode.id)
 
+    def add_movie(self, tmdb_movie: TMDBMovie) -> MovieId:
+        """Adds a movie if it is not already added"""
+        if not self.table(MOVIE).contains(where('id') == tmdb_movie.id):
+            self.table(MOVIE).insert({
+                'id': tmdb_movie.id,
+                'title': tmdb_movie.title,
+                'release_date': tmdb_movie.release_date,
+                'runtime': tmdb_movie.runtime,
+                'watched': NOT_WATCHED_VALUE,
+                'external_ids': tmdb_movie.external_ids or {},
+                'original_language': tmdb_movie.original_language,
+            })
+        else:
+            updates: Dict[str, Any] = {}
+            if tmdb_movie.external_ids is not None:
+                updates['external_ids'] = tmdb_movie.external_ids
+            if tmdb_movie.original_language is not None:
+                updates['original_language'] = tmdb_movie.original_language
+            if updates:
+                self.table(MOVIE).update(updates, where('id') == tmdb_movie.id)
+        return MovieId(tmdb_movie.id)
+
+    def get_movies(self) -> List[Movie]:
+        """Returns movies sorted by title"""
+        return cast(List[Movie], sorted(self.table(MOVIE).all(), key=lambda movie: movie['title'].lower()))
+
+    def get_movie(self, movie_id: MovieId) -> Optional[Movie]:
+        """Returns a single movie"""
+        return cast(Optional[Movie], self.table(MOVIE).get(where('id') == movie_id))
+
+    def delete_movie(self, movie_id: MovieId) -> List[int]:
+        """Removes a movie from the database"""
+        return self.table(MOVIE).remove(where('id') == movie_id)
+
+    def update_movie_external_ids(self, movie_id: MovieId, external_ids: Dict[str, Optional[str]]) -> List[int]:
+        """Stores external identifiers for a movie"""
+        return self.table(MOVIE).update({'external_ids': external_ids}, where('id') == movie_id)
+
+    def update_movie_watched(self, movie_id: MovieId, watched: bool, when: datetime) -> List[int]:
+        """Updates the watched date of a movie"""
+        watched_value = when.isoformat() if watched else NOT_WATCHED_VALUE
+        return self.table(MOVIE).update({'watched': watched_value}, where('id') == movie_id)
+
     def get_shows(self) -> List[Show]:
         """Returns list of all added shows"""
         return cast(List[Show], self.table(SHOW).all())

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/showtime/output.py

@@ -5,7 +5,7 @@ from typing import Callable, Dict, List
 
 from terminaltables import AsciiTable as Table  # type: ignore
 
-from showtime.types import (DecoratedEpisode, Episode, Show, TVMazeEpisode,
+from showtime.types import (DecoratedEpisode, Episode, Movie, Show, TMDBMovie, TVMazeEpisode,
                             TVMazeShow, ShowWithCount)
 
 PrintFunction = Callable[[str], None]
@@ -79,6 +79,33 @@ class Output():
             ])
         return str(Table(data, title='Search Results').table)
 
+    def format_movie_search_results(self, search_result: List[TMDBMovie]) -> str:
+        """Formats TMDB movie search results as a table"""
+        data = [['ID', 'Title', 'Released', 'Language', 'Runtime']]
+        for movie in search_result:
+            data.append([
+                str(movie.id),
+                movie.title,
+                movie.release_date or '',
+                movie.original_language or '',
+                str(movie.runtime) if movie.runtime is not None else '',
+            ])
+        return str(Table(data, title='Movie Search Results').table)
+
+    def movies_table(self, movies: List[Movie]) -> str:
+        """Formats tracked movies as a table"""
+        data = [['ID', 'Title', 'Released', 'Language', 'Runtime', 'Watched']]
+        for movie in movies:
+            data.append([
+                str(movie['id']),
+                movie['title'],
+                movie['release_date'] or '',
+                movie.get('original_language') or '',
+                str(movie['runtime']) if movie['runtime'] is not None else '',
+                movie['watched'],
+            ])
+        return str(Table(data, title='Tracked Movies').table)
+
     def format_episodes(self, show: Show, episodes: List[Episode]) -> str:
         """Formats as table list of episodes"""
         title = f"({show['id']}) {show['name']} - {show['premiered']}"

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/showtime/showtime.py

@@ -3,20 +3,12 @@ from datetime import date, datetime
 from typing import Callable, Dict, List, Optional, Set, Union, cast
 
 import dateutil.parser
-from ratelimit import limits, sleep_and_retry
 
 from showtime.api import Api
 from showtime.config import Config
 from showtime.database import Database, transaction, NOT_WATCHED_VALUE
-from showtime.types import (DecoratedEpisode, Episode, EpisodeId, Show, ShowId, ShowWithCount,
-                            TVMazeEpisode, TVMazeShow)
-
-
-@sleep_and_retry
-@limits(calls=20, period=10)
-def _get_episodes(api: Api, show_id: ShowId) -> List[TVMazeEpisode]:
-    """Downloads show information from API"""
-    return api.episodes_list(show_id)
+from showtime.types import (DecoratedEpisode, Episode, EpisodeId, Movie, MovieId, Show, ShowId, ShowWithCount,
+                            TMDBMovie, TVMazeEpisode, TVMazeShow)
 
 
 def needs_update(episode: Episode, tv_maze_episode: TVMazeEpisode):
@@ -53,6 +45,137 @@ class ShowtimeApp():
             shows = [s for s in shows if query in s['name'].lower()]
         return sorted(shows, key=lambda k: k['name'])
 
+    def movie_search(self, query: str) -> List[Movie]:
+        """Searches tracked movies using the database"""
+        movies = self.database.get_movies()
+        if query:
+            query = query.lower()
+            movies = [movie for movie in movies if query in movie['title'].lower()]
+        return movies
+
+    def movie_search_api(self, query: str) -> List[TMDBMovie]:
+        """Searches TMDB for movie titles"""
+        return self.api.movie_search(query)
+
+    def _movie_with_external_ids(self, movie_id: MovieId) -> TMDBMovie:
+        movie = self.api.movie_get(movie_id)
+        external_ids = self.api.movie_external_ids(movie_id)
+        return movie._replace(external_ids=external_ids)
+
+    def movie_add(self, movie_id: MovieId) -> TMDBMovie:
+        """Adds a movie from TMDB to the database"""
+        movie = self._movie_with_external_ids(movie_id)
+        with transaction(self.database) as transacted_db:
+            transacted_db.add_movie(movie)
+        return movie
+
+    def movie_add_watched(self, movie_id: MovieId, when: datetime) -> TMDBMovie:
+        """Adds a movie and marks it as watched"""
+        movie = self._movie_with_external_ids(movie_id)
+        with transaction(self.database) as transacted_db:
+            transacted_db.add_movie(movie)
+            transacted_db.update_movie_watched(movie.id, True, when)
+        return movie
+
+    def import_imdb_ratings(self, file_name: str,
+                            on_progress: Optional[Callable[[str], None]] = None) -> tuple[int, int]:
+        """Imports watched dates from an IMDb ratings export"""
+        imported = 0
+        skipped = 0
+        with open(file_name, newline='', encoding='utf-8-sig') as csv_file:
+            reader = csv.DictReader(csv_file)
+            required_headers = {'Const', 'Your Rating', 'Date Rated', 'Title Type'}
+            if reader.fieldnames is None or not required_headers.issubset(reader.fieldnames):
+                raise ValueError('IMDb export must include Const, Your Rating, Date Rated, and Title Type columns')
+            rows = list(reader)
+
+            if on_progress:
+                on_progress(f"Starting IMDb ratings import ({len(rows)} rows)")
+
+            imdb_to_tmdb: Dict[str, MovieId] = {}
+            with transaction(self.database) as transacted_db:
+                tracked_movies = transacted_db.get_movies()
+                for movie_number, movie in enumerate(tracked_movies, start=1):
+                    external_ids = movie.get('external_ids')
+                    if external_ids is None:
+                        if on_progress:
+                            on_progress(
+                                f"Fetching IMDb ID for {movie['title']} ({movie_number}/{len(tracked_movies)})"
+                            )
+                        external_ids = self.api.movie_external_ids(MovieId(movie['id']))
+                        transacted_db.update_movie_external_ids(MovieId(movie['id']), external_ids)
+                    imdb_id = external_ids.get('imdb_id')
+                    if imdb_id:
+                        imdb_to_tmdb[imdb_id] = MovieId(movie['id'])
+
+                total_rows = len(rows)
+                for row_number, row in enumerate(rows, start=1):
+                    title = (row.get('Title') or row.get('Const') or 'Unknown title').strip()
+                    title_type = (row.get('Title Type') or '').strip().casefold()
+                    if title_type not in {'movie', 'tv movie', 'tvmovie', 'video', 'short', 'tv short', 'tvshort'}:
+                        skipped += 1
+                        if on_progress:
+                            on_progress(f"Skipped {row_number}/{total_rows}: {title} (not a movie)")
+                        continue
+
+                    imdb_id = (row.get('Const') or '').strip()
+                    rating = (row.get('Your Rating') or '').strip()
+                    date_rated = (row.get('Date Rated') or '').strip()
+                    if not imdb_id or not rating or not date_rated:
+                        skipped += 1
+                        if on_progress:
+                            on_progress(f"Skipped {row_number}/{total_rows}: {title} (incomplete rating)")
+                        continue
+
+                    try:
+                        watched_at = dateutil.parser.parse(date_rated)
+                    except (dateutil.parser.ParserError, OverflowError):
+                        skipped += 1
+                        if on_progress:
+                            on_progress(f"Skipped {row_number}/{total_rows}: {title} (invalid date)")
+                        continue
+
+                    movie_id = imdb_to_tmdb.get(imdb_id)
+                    if movie_id is None:
+                        if on_progress:
+                            on_progress(f"Resolving {row_number}/{total_rows}: {title}")
+                        movie_id = self.api.movie_find_by_imdb_id(imdb_id)
+                        if movie_id is None:
+                            skipped += 1
+                            if on_progress:
+                                on_progress(f"Skipped {row_number}/{total_rows}: {title} (not found in TMDB)")
+                            continue
+                        tmdb_movie = self._movie_with_external_ids(movie_id)
+                        if not tmdb_movie.external_ids or tmdb_movie.external_ids.get('imdb_id') != imdb_id:
+                            skipped += 1
+                            if on_progress:
+                                on_progress(f"Skipped {row_number}/{total_rows}: {title} (IMDb ID mismatch)")
+                            continue
+                        transacted_db.add_movie(tmdb_movie)
+                        movie_id = MovieId(tmdb_movie.id)
+                        imdb_to_tmdb[imdb_id] = movie_id
+
+                    transacted_db.update_movie_watched(movie_id, True, watched_at)
+                    imported += 1
+                    if on_progress:
+                        on_progress(f"Imported {row_number}/{total_rows}: {title}")
+
+        return imported, skipped
+
+    def movie_get(self, movie_id: MovieId) -> Optional[Movie]:
+        """Returns a tracked movie"""
+        return self.database.get_movie(movie_id)
+
+    def movie_remove(self, movie_id: MovieId) -> List[int]:
+        """Removes a tracked movie"""
+        with transaction(self.database) as transacted_db:
+            return transacted_db.delete_movie(movie_id)
+
+    def movie_update_watched(self, movie_id: MovieId, watched: bool, when: datetime) -> List[int]:
+        """Marks a movie as watched or unwatched"""
+        with transaction(self.database) as transacted_db:
+            return transacted_db.update_movie_watched(movie_id, watched, when)
+
     def _sync_episodes(self, db: Database, show_id: ShowId, tv_maze_episodes: List[TVMazeEpisode],
                        on_insert: Optional[Callable[[TVMazeEpisode], None]] = None,
                        on_update: Optional[Callable[[TVMazeEpisode], None]] = None):
@@ -101,7 +224,7 @@ class ShowtimeApp():
             with transaction(self.database) as transacted_db:
                 _show_id = transacted_db.add_show(show)
                 # add episodes to db
-                episodes = _get_episodes(self.api, _show_id)
+                episodes = self.api.episodes_list(_show_id)
                 self._sync_episodes(transacted_db, _show_id, episodes,
                                     on_insert=on_episode_insert, on_update=on_episode_update)
                 if on_show_added:
@@ -170,7 +293,7 @@ class ShowtimeApp():
                 tv_maze_show = self.api.show_get(show_id)
                 if tv_maze_show:
                     transacted_db.update_show(show_id, tv_maze_show)
-                    tv_maze_episodes = _get_episodes(self.api, show_id)
+                    tv_maze_episodes = self.api.episodes_list(show_id)
                     self._sync_episodes(transacted_db, show_id, tv_maze_episodes,
                                         on_insert=on_episode_insert, on_update=on_episode_update)
 

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/showtime/types.py

@@ -1,11 +1,12 @@
 """Showtime Types Module"""
 
 from enum import Enum
-from typing import NamedTuple, Dict
-from typing_extensions import TypedDict
+from typing import Dict, NamedTuple, Optional
+from typing_extensions import NotRequired, TypedDict
 
 ShowId = int
 EpisodeId = int
+MovieId = int
 Date = str
 
 
@@ -29,6 +30,27 @@ class TVMazeEpisode(NamedTuple):
     runtime: int
 
 
+class TMDBMovie(NamedTuple):
+    """TMDB movie result"""
+    id: MovieId
+    title: str
+    release_date: str | None
+    runtime: int | None
+    external_ids: Optional[Dict[str, Optional[str]]] = None
+    original_language: Optional[str] = None
+
+
+class Movie(TypedDict):
+    """DB movie"""
+    id: MovieId
+    title: str
+    release_date: Date | None
+    runtime: int | None
+    watched: Date
+    external_ids: NotRequired[Dict[str, Optional[str]]]
+    original_language: NotRequired[Optional[str]]
+
+
 class ShowStatus(Enum):
     """API Show status"""
     ENDED = 'Ended'

{showtime_cli-0.3.24 → showtime_cli-0.3.26}/showtime_cli.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: showtime-cli
-Version: 0.3.24
+Version: 0.3.26
 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.1
+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.24 → showtime_cli-0.3.26}/showtime_cli.egg-info/requires.txt

@@ -1,4 +1,4 @@
-cmd2==4.2.1
+cmd2==4.2.4
 ratelimit==2.2.1
 tinydb==4.9.0
 terminaltables==3.1.10

showtime_cli-0.3.24/README.md

@@ -1,9 +0,0 @@
-# showtime
-
-Small command line interactive tv show tracker using the TvMaze API.
-
-## Installation
-
-```sh
-pip install showtime-cli
-```

showtime_cli-0.3.24/showtime/api.py

@@ -1,91 +0,0 @@
-"""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 showtime.types import ShowId, TVMazeEpisode, TVMazeShow
-
-API_BASE_URL = "https://api.tvmaze.com"
-
-
-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'])
-
-
-@dataclass
-class HTTPResponse:
-    data: str
-
-
-class HTTPClient():
-    """HTTP Client"""
-
-    def request(self, _method: str, url: str, fields: dict[str, str]={}) -> Any:
-        headers = {
-            "User-Agent": "showtime-cli",
-            "Accept": "application/json"
-        }
-
-        url_parts = list(urlparse(url))
-        url_parts[4] = urlencode(fields)
-        final_url = urlunparse(url_parts)
-        print(final_url)
-        request = urllib.request.Request(final_url, headers=headers)
-        with urllib.request.urlopen(request) as response:
-            return HTTPResponse(data=response.read())
-
-
-class Api():
-    """API Client"""
-
-    def __init__(self, http: HTTPClient) -> None:
-        self.http = http
-
-    def episodes_list(self, show_id: ShowId) -> List[TVMazeEpisode]:
-        """returns list of episodes for a show"""
-        response = self.http.request('GET', 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.http.request('GET', 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.http.request('GET', 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 get_default_pool_manager():
-    return HTTPClient()
-
-