plexutil 1.0.0__tar.gz

plexutil-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 CARLOS FLOREZ
+
+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.

plexutil-1.0.0/PKG-INFO

@@ -0,0 +1,36 @@
+Metadata-Version: 2.1
+Name: plexutil
+Version: 1.0.0
+Author-email: Carlos Florez <carlos@florez.co.uk>
+Maintainer-email: Carlos Florez <carlos@florez.co.uk>
+License: MIT License
+        
+        Copyright (c) 2024 CARLOS FLOREZ
+        
+        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.
+        
+Project-URL: Repository, https://github.com/florez-carlos/plexutil
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.11.6
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# plexutil
+source init.sh

plexutil-1.0.0/README.md

@@ -0,0 +1,2 @@
+# plexutil
+source init.sh

plexutil-1.0.0/pyproject.toml

@@ -0,0 +1,27 @@
+[build-system]
+requires = ["setuptools>=62.6"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "plexutil"
+version = "1.0.0"
+requires-python = ">=3.11.6"
+authors = [
+  {name = "Carlos Florez", email = "carlos@florez.co.uk"}
+]
+maintainers = [
+  {name = "Carlos Florez", email = "carlos@florez.co.uk"}
+]
+description = ""
+readme = "README.md"
+license = {file = "LICENSE"}
+classifiers = [
+  "Development Status :: 5 - Production/Stable",
+  "Programming Language :: Python :: 3.11",
+]
+
+[tool.setuptools.dynamic]
+dependencies = {file = ["requirements.txt"]}
+
+[project.urls]
+Repository = "https://github.com/florez-carlos/plexutil"

plexutil-1.0.0/setup.cfg

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

plexutil-1.0.0/src/core/library.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+import time
+from abc import ABC, abstractmethod
+from typing import TYPE_CHECKING
+
+from src.exception.library_poll_timeout_error import LibraryPollTimeoutError
+from src.plex_util_logger import PlexUtilLogger
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from plexapi.audio import Audio
+    from plexapi.server import PlexServer
+    from plexapi.video import Video
+
+    from src.dto.library_preferences_dto import LibraryPreferencesDTO
+    from src.enum.agent import Agent
+    from src.enum.language import Language
+    from src.enum.library_name import LibraryName
+    from src.enum.scanner import Scanner
+
+from alive_progress import alive_bar
+from plexapi.exceptions import NotFound
+
+from src.enum.library_type import LibraryType
+from src.exception.library_op_error import LibraryOpError
+from src.exception.library_unsupported_error import LibraryUnsupportedError
+
+
+class Library(ABC):
+    def __init__(
+        self,
+        plex_server: PlexServer,
+        name: LibraryName,
+        library_type: LibraryType,
+        agent: Agent,
+        scanner: Scanner,
+        location: Path,
+        language: Language,
+        preferences: LibraryPreferencesDTO,
+    ) -> None:
+        self.plex_server = plex_server
+        self.name = name
+        self.library_type = library_type
+        self.agent = agent
+        self.scanner = scanner
+        self.location = location
+        self.language = language
+        self.preferences = preferences
+
+    @abstractmethod
+    def create(self) -> None:
+        raise NotImplementedError
+
+    @abstractmethod
+    def delete(self) -> None:
+        op_type = "DELETE"
+
+        info = (
+            "Deleting library: \n"
+            f"Name: {self.name.value}\n"
+            f"Type: {self.library_type.value}\n"
+            f"Agent: {self.agent.value}\n"
+            f"Scanner: {self.scanner.value}\n"
+            f"Location: {self.location!s}\n"
+            f"Language: {self.language.value}\n"
+            f"Preferences: {self.preferences.music}\n"
+        )
+        PlexUtilLogger.get_logger().info(info)
+
+        try:
+            result = self.plex_server.library.section(self.name.value)
+
+            if result:
+                result.delete()
+            else:
+                description = "Nothing found"
+                raise LibraryOpError(
+                    op_type=op_type,
+                    description=description,
+                    library_type=self.library_type,
+                )
+
+        except NotFound:
+            raise LibraryOpError(
+                op_type=op_type,
+                library_type=self.library_type,
+            ) from NotFound
+
+    @abstractmethod
+    def exists(self) -> bool:
+        debug = (
+            "Checking library exists: \n"
+            f"Name: {self.name.value}\n"
+            f"Type: {self.library_type.value}\n"
+            f"Agent: {self.agent.value}\n"
+            f"Scanner: {self.scanner.value}\n"
+            f"Location: {self.location!s}\n"
+            f"Language: {self.language.value}\n"
+            f"Preferences: {self.preferences.movie}\n"
+        )
+        try:
+            result = self.plex_server.library.section(self.name.value)
+
+            if not result:
+                debug = debug + "-Not found-"
+                PlexUtilLogger.get_logger().debug(debug)
+                return False
+
+        except NotFound:
+            debug = debug + "-Not found-"
+            PlexUtilLogger.get_logger().debug(debug)
+            return False
+
+        PlexUtilLogger.get_logger().debug(debug)
+        return True
+
+    def poll(
+        self,
+        requested_attempts: int = 0,
+        expected_count: int = 0,
+        interval_seconds: int = 0,
+        tvdb_ids: list[int] | None = None,
+    ) -> None:
+        current_count = len(self.query(tvdb_ids))
+        init_offset = abs(expected_count - current_count)
+
+        debug = (
+            f"Requested attempts: {requested_attempts!s}\n"
+            f"Interval seconds: {interval_seconds!s}\n"
+            f"Current count: {current_count!s}\n"
+            f"Expected count: {expected_count!s}\n"
+            f"Net change: {init_offset!s}\n"
+        )
+
+        PlexUtilLogger.get_logger().debug(debug)
+
+        with alive_bar(init_offset) as bar:
+            attempts = 0
+            display_count = 0
+            offset = init_offset
+
+            while attempts < requested_attempts:
+                updated_current_count = len(self.query(tvdb_ids))
+                offset = abs(updated_current_count - current_count)
+                current_count = updated_current_count
+
+                if current_count == expected_count:
+                    for _ in range(abs(current_count - display_count)):
+                        bar()
+
+                    break
+
+                for _ in range(offset):
+                    display_count = display_count + 1
+                    bar()
+
+                time.sleep(interval_seconds)
+                attempts = attempts + 1
+                if attempts >= requested_attempts:
+                    raise LibraryPollTimeoutError
+
+    def query(
+        self,
+        tvdb_ids: list[int] | None = None,
+    ) -> list[Audio] | list[Video]:
+        op_type = "QUERY"
+
+        if tvdb_ids is None:
+            tvdb_ids = []
+
+        debug = (
+            "Performing query:\n"
+            f"Name: {self.name.value}\n"
+            f"Library Type: {self.library_type.value}\n"
+            f"TVDB Ids: {tvdb_ids}\n"
+        )
+        PlexUtilLogger.get_logger().debug(debug)
+
+        try:
+            if self.library_type is LibraryType.MUSIC:
+                return self.plex_server.library.section(
+                    self.name.value,
+                ).searchTracks()
+
+            elif self.library_type is LibraryType.TV:
+                shows = self.plex_server.library.section(self.name.value).all()
+                shows_filtered = []
+
+                if tvdb_ids:
+                    for show in shows:
+                        guids = show.guids
+                        tvdb_prefix = "tvdb://"
+                        for guid in guids:
+                            if tvdb_prefix in guid.id:
+                                tvdb = guid.id.replace(tvdb_prefix, "")
+                                if int(tvdb) in tvdb_ids:
+                                    shows_filtered.append(show)
+                            else:
+                                description = (
+                                    "Expected ("
+                                    + tvdb_prefix
+                                    + ") but show does not have any: "
+                                    + guid.id
+                                )
+                                LibraryOpError(
+                                    op_type=op_type,
+                                    library_type=self.library_type,
+                                    description=description,
+                                )
+
+                return shows_filtered
+
+            else:
+                raise LibraryUnsupportedError(
+                    op_type=op_type,
+                    library_type=self.library_type,
+                )
+
+        except NotFound:
+            debug = "Received Not Found on a Query operation"
+            PlexUtilLogger.get_logger().debug(debug)
+            return []

plexutil-1.0.0/src/core/movie_library.py

@@ -0,0 +1,68 @@
+from pathlib import Path
+
+from plexapi.server import PlexServer
+
+from src.core.library import Library
+from src.dto.library_preferences_dto import LibraryPreferencesDTO
+from src.enum.agent import Agent
+from src.enum.language import Language
+from src.enum.library_name import LibraryName
+from src.enum.library_type import LibraryType
+from src.enum.scanner import Scanner
+from src.plex_util_logger import PlexUtilLogger
+
+
+class MovieLibrary(Library):
+    def __init__(
+        self,
+        plex_server: PlexServer,
+        location: Path,
+        language: Language,
+        preferences: LibraryPreferencesDTO,
+    ) -> None:
+        super().__init__(
+            plex_server,
+            LibraryName.MOVIE,
+            LibraryType.MOVIE,
+            Agent.MOVIE,
+            Scanner.MOVIE,
+            location,
+            language,
+            preferences,
+        )
+
+    def create(self) -> None:
+        info = (
+            "Creating movie library: \n"
+            f"Name: {self.name.value}\n"
+            f"Type: {self.library_type.value}\n"
+            f"Agent: {self.agent.value}\n"
+            f"Scanner: {self.scanner.value}\n"
+            f"Location: {self.location!s}\n"
+            f"Language: {self.language.value}\n"
+            f"Preferences: {self.preferences.movie}\n"
+        )
+
+        PlexUtilLogger.get_logger().info(info)
+
+        self.plex_server.library.add(
+            name=self.name.value,
+            type=self.library_type.value,
+            agent=self.agent.value,
+            scanner=self.scanner.value,
+            location=str(self.location),
+            language=self.language.value,
+        )
+
+        # This line triggers a refresh of the library
+        self.plex_server.library.sections()
+
+        self.plex_server.library.section(self.name.value).editAdvanced(
+            **self.preferences.movie,
+        )
+
+    def delete(self) -> None:
+        return super().delete()
+
+    def exists(self) -> bool:
+        return super().exists()

plexutil-1.0.0/src/core/music_library.py

@@ -0,0 +1,105 @@
+from pathlib import Path
+
+from plexapi.server import PlexServer
+
+from src.core.library import Library
+from src.dto.library_preferences_dto import LibraryPreferencesDTO
+from src.dto.music_playlist_file_dto import MusicPlaylistFileDTO
+from src.enum.agent import Agent
+from src.enum.language import Language
+from src.enum.library_name import LibraryName
+from src.enum.library_type import LibraryType
+from src.enum.scanner import Scanner
+from src.exception.library_op_error import LibraryOpError
+from src.plex_util_logger import PlexUtilLogger
+from src.util.query_builder import QueryBuilder
+
+
+class MusicLibrary(Library):
+    def __init__(
+        self,
+        plex_server: PlexServer,
+        location: Path,
+        language: Language,
+        preferences: LibraryPreferencesDTO,
+        music_playlist_file_dto: MusicPlaylistFileDTO,
+    ) -> None:
+        super().__init__(
+            plex_server,
+            LibraryName.MUSIC,
+            LibraryType.MUSIC,
+            Agent.MUSIC,
+            Scanner.MUSIC,
+            location,
+            language,
+            preferences,
+        )
+        self.music_playlist_file_dto = music_playlist_file_dto
+
+    def create(self) -> None:
+        op_type = "CREATE"
+
+        part = ""
+
+        query_builder = QueryBuilder(
+            "/library/sections",
+            name=LibraryName.MUSIC.value,
+            the_type=LibraryType.MUSIC.value,
+            agent=Agent.MUSIC.value,
+            scanner=Scanner.MUSIC.value,
+            language=Language.ENGLISH_US.value,
+            importFromiTunes="",
+            enableAutoPhotoTags="",
+            location=str(self.location),
+            prefs=self.preferences.music,
+        )
+
+        part = query_builder.build()
+
+        info = (
+            "Creating music library: \n"
+            f"Name: {self.name.value}\n"
+            f"Type: {self.library_type.value}\n"
+            f"Agent: {self.agent.value}\n"
+            f"Scanner: {self.scanner.value}\n"
+            f"Location: {self.location!s}\n"
+            f"Language: {self.language.value}\n"
+            f"Preferences: {self.preferences.music}\n"
+        )
+
+        debug = f"Query: {part}\n"
+
+        PlexUtilLogger.get_logger().info(info)
+        PlexUtilLogger.get_logger().debug(debug)
+
+        # This posts a music library
+        if part:
+            self.plex_server.query(
+                part,
+                method=self.plex_server._session.post,
+            )
+        else:
+            description = "Query Builder has not built a part!"
+            raise LibraryOpError(
+                op_type=op_type,
+                library_type=self.library_type,
+                description=description,
+            )
+
+        # This triggers a refresh of the library
+        self.plex_server.library.sections()
+
+        info = (
+            "Checking server music "
+            "meets expected "
+            f"count: {self.music_playlist_file_dto.track_count!s}\n"
+        )
+        PlexUtilLogger.get_logger().info(info)
+
+        self.poll(200, self.music_playlist_file_dto.track_count, 10)
+
+    def delete(self) -> None:
+        return super().delete()
+
+    def exists(self) -> bool:
+        return super().exists()

plexutil-1.0.0/src/core/playlist.py

@@ -0,0 +1,145 @@
+from pathlib import Path
+
+from plexapi.server import PlexServer
+
+from src.core.library import Library
+from src.dto.library_preferences_dto import LibraryPreferencesDTO
+from src.dto.music_playlist_file_dto import MusicPlaylistFileDTO
+from src.enum.agent import Agent
+from src.enum.language import Language
+from src.enum.library_name import LibraryName
+from src.enum.library_type import LibraryType
+from src.enum.scanner import Scanner
+from src.exception.library_op_error import LibraryOpError
+from src.plex_util_logger import PlexUtilLogger
+from src.util.path_ops import PathOps
+
+
+class Playlist(Library):
+    def __init__(
+        self,
+        plex_server: PlexServer,
+        location: Path,
+        language: Language,
+        music_playlist_file_dto: MusicPlaylistFileDTO,
+    ) -> None:
+        super().__init__(
+            plex_server,
+            LibraryName.MUSIC,
+            LibraryType.MUSIC,
+            Agent.MUSIC,
+            Scanner.MUSIC,
+            location,
+            language,
+            LibraryPreferencesDTO({}, {}, {}, {}),
+        )
+        self.music_playlist_file_dto = music_playlist_file_dto
+
+    def create(self) -> None:
+        op_type = "CREATE"
+        tracks = self.plex_server.library.section(
+            self.name.value,
+        ).searchTracks()
+        plex_track_dict = {}
+        plex_playlist = []
+
+        playlist_names = [
+            x.name for x in self.music_playlist_file_dto.playlists
+        ]
+
+        info = "Creating playlist library: \n" f"Playlists: {playlist_names}\n"
+
+        PlexUtilLogger.get_logger().info(info)
+
+        info = (
+            "Checking server track count "
+            f"meets expected "
+            f"count: {self.music_playlist_file_dto.track_count!s}\n"
+        )
+        PlexUtilLogger.get_logger().info(info)
+        self.poll(10, self.music_playlist_file_dto.track_count, 10)
+
+        playlists = self.music_playlist_file_dto.playlists
+
+        for track in tracks:
+            plex_track_absolute_location = track.locations[0]
+            plex_track_path = PathOps.get_path_from_str(
+                plex_track_absolute_location,
+            )
+            plex_track_full_name = plex_track_path.name
+            plex_track_name = plex_track_full_name.rsplit(".", 1)[0]
+            plex_track_dict[plex_track_name] = track
+
+        for playlist in playlists:
+            playlist_name = playlist.name
+            songs = playlist.songs
+
+            for song in songs:
+                song_name = song.name
+
+                if plex_track_dict.get(song_name) is None:
+                    description = (
+                        f"File in music playlist: '{song_name}' "
+                        "does not exist in server"
+                    )
+                    raise LibraryOpError(
+                        op_type=op_type,
+                        library_type=self.library_type,
+                        description=description,
+                    )
+
+                plex_playlist.append(plex_track_dict.get(song_name))
+
+            self.plex_server.createPlaylist(
+                title=playlist_name,
+                items=plex_playlist,
+            )
+            plex_playlist = []
+
+    def delete(self) -> None:
+        playlist_names = [
+            x.name for x in self.music_playlist_file_dto.playlists
+        ]
+
+        info = (
+            "Deleting music playlists: \n"
+            f"Playlists: {playlist_names}\n"
+            f"Location: {self.location!s}\n"
+        )
+        PlexUtilLogger.get_logger().info(info)
+
+        server_playlists = self.plex_server.playlists(playlistType="audio")
+
+        debug = f"Playlists available in server: {server_playlists}"
+        PlexUtilLogger.get_logger().debug(debug)
+
+        for playlist in server_playlists:
+            if playlist.title in playlist_names:
+                playlist.delete()
+
+    def exists(self) -> bool:
+        playlist_names = [
+            x.name for x in self.music_playlist_file_dto.playlists
+        ]
+        playlists = self.plex_server.playlists(playlistType="audio")
+
+        debug = (
+            f"Checking playlists exist\n"
+            f"Requested: {playlist_names}\n"
+            f"In server: {playlists}\n"
+        )
+        PlexUtilLogger.get_logger().debug(debug)
+
+        if not playlists or not playlist_names:
+            return False
+
+        all_exist = True
+        for playlist_name in playlist_names:
+            if playlist_name in [x.title for x in playlists]:
+                continue
+            all_exist = False
+
+        debug = f"All exist: {all_exist}"
+        PlexUtilLogger.get_logger().debug(debug)
+
+        return all_exist