plexflow 0.0.64__py3-none-any.whl

plexflow/core/metadata/providers/universal/movie.py

@@ -0,0 +1,130 @@
+from datetime import datetime
+from plexflow.core.metadata.auto.auto_providers.auto.movie import AutoMovie
+from typing import List, Any
+from langcodes import standardize_tag
+
+class UniversalMovie:
+    def __init__(self, providers: List[AutoMovie]):
+        self.providers = providers
+    
+    @property
+    def plex_rating_key(self) -> str:
+        for p in self.providers:
+            if p.source == "plex":
+                return p.id
+        
+    @property
+    def title(self) -> str:
+        for p in self.providers:
+            if p.title:
+                return p.title
+    
+    @property
+    def year(self) -> int:
+        for p in self.providers:
+            if p.year:
+                return p.year
+    
+    @property
+    def rank(self) -> int:
+        for p in self.providers:
+            if p.rank:
+                return p.rank
+    
+    @property
+    def release_date(self) -> datetime:
+        for p in self.providers:
+            if p.release_date:
+                return p.release_date
+        
+    @property
+    def imdb_id(self) -> str:
+        for p in self.providers:
+            if p.imdb_id:
+                return p.imdb_id
+    
+    @property
+    def titles(self) -> List[str]:
+        results = set()
+        
+        for p in self.providers:
+            results.update(p.titles)
+            results.add(p.title)
+
+        return list(results)        
+
+    @property
+    def runtime(self) -> int:
+        for p in self.providers:
+            if p.runtime:
+                return p.runtime
+    
+    @property
+    def summary(self) -> str:
+        for p in self.providers:
+            if p.summary:
+                return p.summary
+    
+    @property
+    def sources(self) -> List[str]:
+        return list({p.source for p in self.providers})
+
+    @property
+    def language(self) -> str:
+        for p in self.providers:
+            if p.language:
+                return standardize_tag(p.language)
+
+    @property
+    def release_dates(self) -> List[datetime]:
+        return list({p.release_date for p in self.providers if isinstance(p.release_date, datetime)})
+    
+    @property
+    def years(self) -> List[int]:
+        return list({p.year for p in self.providers if isinstance(p.year, int)})
+    
+    @property
+    def runtimes(self) -> List[int]:
+        return list({p.runtime for p in self.providers if isinstance(p.runtime, int)})
+    
+    @property
+    def languages(self) -> List[str]:
+        return list({standardize_tag(p.language) for p in self.providers if isinstance(p.language, str)})
+    
+    @property
+    def imdb_ids(self) -> List[str]:
+        return list({p.imdb_id for p in self.providers if isinstance(p.imdb_id, str)})
+    
+    def _is_field_consistent(self, field: str) -> bool:
+        return len(getattr(self, field)) == 1
+    
+    @property
+    def is_imdb_id_consistent(self) -> bool:
+        return self._is_field_consistent("imdb_ids")
+    
+    @property
+    def is_year_consistent(self) -> bool:
+        return self._is_field_consistent("years")
+    
+    @property
+    def is_release_date_consistent(self) -> bool:
+        return self._is_field_consistent("release_dates")
+    
+    @property
+    def is_runtime_consistent(self) -> bool:
+        return self._is_field_consistent("runtimes")
+    
+    @property
+    def is_language_consistent(self) -> bool:
+        return self._is_field_consistent("languages")
+
+    @property
+    def is_released(self) -> bool:
+        now = datetime.now()
+        return all(d <= now for d in self.release_dates)
+
+    @property
+    def days_until_release(self) -> int:
+        now = datetime.now()
+        
+        return min((d - now).days for d in self.release_dates)

plexflow/core/metadata/providers/universal/old.py

@@ -0,0 +1,192 @@
+from datetime import datetime
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, Undefined
+from plexflow.core.metadata.providers.tmdb.datatypes import TmdbMovie
+from plexflow.core.metadata.providers.tvdb.datatypes import TvdbMovie
+from plexflow.core.metadata.providers.imdb.datatypes import ImdbMovie
+from plexflow.core.metadata.providers.moviemeter.datatypes import MovieMeterMovie
+from plexflow.core.metadata.providers.plex.datatypes import PlexMovieMetadata
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class UniversalMovie:
+    """
+    Represents a movie with data from TmdbMovie, TvdbMovie, ImdbMovie, and MovieMeterMovie.
+    
+    Attributes:
+        tmdb_movie (TmdbMovie): The TmdbMovie object.
+        tvdb_movie (TvdbMovie): The TvdbMovie object.
+        imdb_movie (ImdbMovie): The ImdbMovie object.
+        moviemeter_movie (MovieMeterMovie): The MovieMeterMovie object.
+    """
+    tmdb_movie: TmdbMovie
+    tvdb_movie: TvdbMovie
+    imdb_movie: ImdbMovie
+    moviemeter_movie: MovieMeterMovie
+    plex_movie: PlexMovieMetadata
+
+    @property
+    def is_release_date_consistent(self) -> bool:
+        """
+        Checks whether tmdb, tvdb, and imdb have the same release date.
+        
+        Returns:
+            bool: True if the release dates are the same, False otherwise.
+        """
+        if self.tmdb_movie.release_date and self.tvdb_movie.first_release.date and self.imdb_movie.release_date:
+            return self.tmdb_movie.release_date == self.tvdb_movie.first_release.date == self.imdb_movie.release_date.strftime("%Y-%m-%d")
+        return False
+
+    @property
+    def is_year_consistent(self) -> bool:
+        """
+        Checks whether tmdb, tvdb, imdb, and moviemeter have the same release year.
+        
+        Returns:
+            bool: True if the release years are the same, False otherwise.
+        """
+        if self.tmdb_movie.release_date and self.tvdb_movie.first_release.date and self.imdb_movie.release_date and self.moviemeter_movie.year:
+            tmdb_year = datetime.strptime(self.tmdb_movie.release_date, "%Y-%m-%d").year
+            tvdb_year = datetime.strptime(self.tvdb_movie.first_release.date, "%Y-%m-%d").year
+            imdb_year = self.imdb_movie.release_date.year
+            moviemeter_year = self.moviemeter_movie.year
+            return tmdb_year == tvdb_year == imdb_year == moviemeter_year
+        return False
+
+    @property
+    def titles(self) -> set:
+        """
+        Gets a set of all possible titles for the movie.
+        
+        Returns:
+            set: A set of all possible titles for the movie in lowercase.
+        """
+        titles = set()
+        if self.tmdb_movie.title:
+            titles.add(self.tmdb_movie.title.lower())
+        if self.tvdb_movie.name:
+            titles.add(self.tvdb_movie.name.lower())
+        if self.imdb_movie.title:
+            titles.add(self.imdb_movie.title.lower())
+        if self.moviemeter_movie.title:
+            titles.add(self.moviemeter_movie.title.lower())
+        if self.tmdb_movie.alternative_titles:
+            for alt_title in self.tmdb_movie.alternative_titles.titles:
+                titles.add(alt_title.title.lower())
+        return titles
+
+    @property
+    def imdb(self) -> str:
+        """
+        Gets the IMDb ID of the movie.
+        
+        Returns:
+            str: The IMDb ID of the movie.
+        """
+        return self.tmdb_movie.imdb_id
+
+    @property
+    def title(self) -> str:
+        """
+        Gets the title of the movie.
+        
+        Returns:
+            str: The title of the movie.
+        """
+        return self.tmdb_movie.title
+
+    @property
+    def year(self) -> int:
+        """
+        Gets the year of the movie.
+        
+        Returns:
+            int: The year of the movie. If the year is not available in tmdb, it uses tvdb, then imdb, then moviemeter.
+        """
+        if self.tmdb_movie.release_date:
+            return datetime.strptime(self.tmdb_movie.release_date, "%Y-%m-%d").year
+        elif self.tvdb_movie.first_release.date:
+            return datetime.strptime(self.tvdb_movie.first_release.date, "%Y-%m-%d").year
+        elif self.imdb_movie.release_date:
+            return self.imdb_movie.release_date.year
+        elif self.moviemeter_movie.year:
+            return self.moviemeter_movie.year
+        else:
+            raise ValueError("Year is not available in tmdb, tvdb, imdb, and moviemeter.")
+
+    @property
+    def is_released(self) -> bool:
+        """
+        Checks whether the movie is already released.
+        
+        Returns:
+            bool: True if the movie is already released, False otherwise. If the status is not available in tmdb, it uses tvdb, then imdb.
+        """
+        if not self.tmdb_movie.release_date and not self.tvdb_movie.first_release.date and not self.imdb_movie.release_date:
+            raise ValueError("Status is not available in tmdb, tvdb, and imdb.")
+            
+        now = datetime.now()
+        if self.tmdb_movie.release_date:
+            tmdb_date = datetime.strptime(self.tmdb_movie.release_date, "%Y-%m-%d")
+            if tmdb_date <= now:
+                return True
+        if self.tvdb_movie.first_release.date:
+            tvdb_date = datetime.strptime(self.tvdb_movie.first_release.date, "%Y-%m-%d")
+            if tvdb_date <= now:
+                return True
+        if self.imdb_movie.release_date:
+            if self.imdb_movie.release_date <= now:
+                return True
+        return False
+
+    @property
+    def days_until_release(self) -> int:
+        """
+        Gets the number of days until release.
+        
+        Returns:
+            int: The number of days until release. If different release dates, it uses the closest.
+        """
+        if self.tmdb_movie.release_date and self.tvdb_movie.first_release.date and self.imdb_movie.release_date:
+            tmdb_release_date = datetime.strptime(self.tmdb_movie.release_date, "%Y-%m-%d")
+            tvdb_release_date = datetime.strptime(self.tvdb_movie.first_release.date, "%Y-%m-%d")
+            imdb_release_date = self.imdb_movie.release_date
+            return min((tmdb_release_date - datetime.now()).days, (tvdb_release_date - datetime.now()).days, (imdb_release_date - datetime.now()).days)
+        elif self.tmdb_movie.release_date:
+            return (datetime.strptime(self.tmdb_movie.release_date, "%Y-%m-%d") - datetime.now()).days
+        elif self.tvdb_movie.first_release.date:
+            return (datetime.strptime(self.tvdb_movie.first_release.date, "%Y-%m-%d") - datetime.now()).days
+        elif self.imdb_movie.release_date:
+            return (self.imdb_movie.release_date - datetime.now()).days
+        else:
+            raise ValueError("Release date is not available in tmdb, tvdb, and imdb.")
+
+    @property
+    def rank(self) -> int:
+        """
+        Gets the IMDb rank of the movie.
+        
+        Returns:
+            int: The IMDb rank of the movie.
+        """
+        return self.imdb_movie.rank
+
+    @property
+    def rating(self) -> float:
+        """
+        Gets the IMDb rating of the movie.
+        
+        Returns:
+            float: The IMDb rating of the movie.
+        """
+        return self.imdb_movie.rating
+
+    @property
+    def votes(self) -> int:
+        """
+        Gets the IMDb votes of the movie.
+        
+        Returns:
+            int: The IMDb votes of the movie.
+        """
+        return self.imdb_movie.votes

plexflow/core/metadata/providers/universal/show.py

@@ -0,0 +1,107 @@
+from datetime import datetime
+from dataclasses import dataclass
+from dataclasses_json import dataclass_json, Undefined
+from plexflow.core.metadata.providers.tmdb.datatypes import TmdbShow
+from plexflow.core.metadata.providers.tvdb.tv_datatypes import TvdbShow
+from plexflow.core.metadata.providers.imdb.datatypes import ImdbShow
+from plexflow.core.metadata.providers.plex.datatypes import PlexShowMetadata
+
+@dataclass_json(undefined=Undefined.EXCLUDE)
+@dataclass
+class UniversalShow:
+    tmdb_show: TmdbShow
+    tvdb_show: TvdbShow
+    plex_show: PlexShowMetadata
+    imdb_show: ImdbShow
+    
+    @property
+    def is_release_date_consistent(self) -> bool:
+        """
+        Check if the release dates from different providers (TMDB, TVDB, and IMDb) are consistent.
+
+        Returns:
+            bool: True if the release dates are consistent, False otherwise.
+        """
+        tmdb_date = datetime.strptime(self.tmdb_show.first_air_date, "%Y-%m-%d")
+        tvdb_date = datetime.strptime(self.tvdb_show.firstAired, "%Y-%m-%d")
+        imdb_date = datetime.strptime(self.imdb_show.release_date, "%Y-%m-%d")
+
+        return tmdb_date == tvdb_date == imdb_date
+        
+    @property
+    def is_year_consistent(self) -> bool:
+        tmdb_date = datetime.strptime(self.tmdb_show.first_air_date, "%Y-%m-%d")
+        tvdb_year = self.tvdb_show.year
+        plex_year = self.plex_show.year
+        return tmdb_date.year == tvdb_year == plex_year
+
+    @property
+    def titles(self) -> set:
+        title_set = set()
+        
+        title_set.add(self.tmdb_show.original_name)
+        title_set.add(self.tvdb_show.name)
+        title_set.update(alias.name for alias in self.tvdb_show.aliases)
+        title_set.update(title.title for title in self.tmdb_show.alternative_titles.results)
+        title_set.add(self.plex_show.title)
+        title_set.add(self.imdb_show.title)
+        
+        return set(map(lambda s: s.lower().strip(), title_set))
+
+    @property
+    def imdb(self) -> str:
+        """
+        Gets the IMDb ID of the movie.
+        
+        Returns:
+            str: The IMDb ID of the movie.
+        """
+        return self.tmdb_show.imdb_id
+
+    @property
+    def title(self) -> str:
+        """
+        Gets the title of the movie.
+        
+        Returns:
+            str: The title of the movie.
+        """
+        return self.tvdb_show.name
+
+    @property
+    def year(self) -> int:
+        return self.tvdb_show.year
+
+    @property
+    def is_released(self) -> bool:
+        tmdb_date = datetime.strptime(self.tmdb_show.first_air_date, "%Y-%m-%d")
+        tvdb_date = datetime.strptime(self.tvdb_show.firstAired, "%Y-%m-%d")
+        imdb_date = datetime.strptime(self.imdb_show.release_date, "%Y-%m-%d")
+        
+        now = datetime.now()
+        return tmdb_date < now or tvdb_date < now or imdb_date < now
+
+    @property
+    def days_until_release(self) -> int:
+        tmdb_date = datetime.strptime(self.tmdb_show.first_air_date, "%Y-%m-%d")
+        tvdb_date = datetime.strptime(self.tvdb_show.firstAired, "%Y-%m-%d")
+        imdb_date = datetime.strptime(self.imdb_show.release_date, "%Y-%m-%d")
+        
+        now = datetime.now()
+        tmdb_days = (tmdb_date - now).days
+        tvdb_days = (tvdb_date - now).days
+        imdb_days = (imdb_date - now).days
+        
+        return min(tmdb_days, tvdb_days, imdb_days)
+
+    @property
+    def rank(self) -> int:
+        return self.imdb_show.rank
+    
+    @property
+    def rating(self) -> float:
+        return self.imdb_show.rating
+
+    @property
+    def votes(self) -> int:
+        return self.imdb_show.votes

plexflow/core/plex/api/context/authorized.py

@@ -0,0 +1,15 @@
+from plexflow.utils.api.context.http import HttpRequestContext
+from plexflow.core.plex.token.auto_token import PlexAutoToken
+
+class PlexAuthorizedRequestContext(HttpRequestContext):
+    """
+    A class for setting up a default request context for Plex API with X-Plex-Token header.
+    
+    Args:
+        base_url (str): The base URL for the Plex API.
+        x_plex_token (str): The X-Plex-Token for the Plex API.
+    """
+    
+    def __init__(self, base_url: str, x_plex_token: str = None):
+        # Initialize the parent class with the base_url and default_headers
+        super().__init__(base_url, {'X-Plex-Token': PlexAutoToken(plex_token=x_plex_token).get_token(), 'Accept': 'application/json'})

plexflow/core/plex/api/context/discover.py

@@ -0,0 +1,14 @@
+from plexflow.core.plex.api.context.authorized import PlexAuthorizedRequestContext
+from plexflow.core.plex.token.auto_token import PlexAutoToken
+import os
+
+class PlexDiscoverRequestContext(PlexAuthorizedRequestContext):
+    """
+    A class for setting up a default request context for Plex Discover API with X-Plex-Token header.
+    """
+
+    def __init__(self, base_url: str = None, x_plex_token: str = None):
+        # Initialize the parent class with the base_url and default_headers
+        super().__init__(base_url or f'https://discover.provider.plex.tv', 
+                         {'X-Plex-Token': PlexAutoToken(plex_token=x_plex_token).get_token(), 
+                          'Accept': 'application/json'})

plexflow/core/plex/api/context/library.py

@@ -0,0 +1,14 @@
+from plexflow.core.plex.api.context.authorized import PlexAuthorizedRequestContext
+from plexflow.core.plex.token.auto_token import PlexAutoToken
+import os
+
+class PlexLibraryRequestContext(PlexAuthorizedRequestContext):
+    """
+    A class for setting up a default request context for Plex Library API with X-Plex-Token header.
+    """
+
+    def __init__(self, base_url: str = None, x_plex_token: str = None):
+        # Initialize the parent class with the base_url and default_headers
+        super().__init__(base_url or f'http://{os.getenv("PLEX_HOST")}:{os.getenv("PLEX_PORT", 32400)}', 
+                         {'X-Plex-Token': PlexAutoToken(plex_token=x_plex_token).get_token(), 
+                          'Accept': 'application/json'})